feat: dual code hash

cmd/devp2p/internal/ethtest/snap.go

@@ -261,11 +261,11 @@ func (s *Suite) TestSnapGetByteCodes(t *utesting.T) {
 			expHashes: 0,
 		},
 		{
-			nBytes: 10000, hashes: []common.Hash{types.EmptyCodeHash},
+			nBytes: 10000, hashes: []common.Hash{types.EmptyKeccakCodeHash},
 			expHashes: 1,
 		},
 		{
-			nBytes: 10000, hashes: []common.Hash{types.EmptyCodeHash, types.EmptyCodeHash, types.EmptyCodeHash},
+			nBytes: 10000, hashes: []common.Hash{types.EmptyKeccakCodeHash, types.EmptyKeccakCodeHash, types.EmptyKeccakCodeHash},
 			expHashes: 3,
 		},
 		// The existing bytecodes
@@ -357,7 +357,7 @@ func (s *Suite) TestSnapTrieNodes(t *utesting.T) {
 	for i := 1; i <= 65; i++ {
 		accPaths = append(accPaths, pathTo(i))
 	}
-	empty := types.EmptyCodeHash
+	empty := types.EmptyKeccakCodeHash
 	for i, tc := range []trieNodesTest{
 		{
 			root:      s.chain.RootAt(999),

cmd/geth/snapshot.go

@@ -338,9 +338,9 @@ func traverseState(ctx *cli.Context) error {
 				return storageIter.Err
 			}
 		}
-		if !bytes.Equal(acc.CodeHash, types.EmptyCodeHash.Bytes()) {
-			if !rawdb.HasCode(chaindb, common.BytesToHash(acc.CodeHash)) {
-				log.Error("Code is missing", "hash", common.BytesToHash(acc.CodeHash))
+		if !bytes.Equal(acc.KeccakCodeHash, types.EmptyKeccakCodeHash.Bytes()) {
+			if !rawdb.HasCode(chaindb, common.BytesToHash(acc.KeccakCodeHash)) {
+				log.Error("Code is missing", "hash", common.BytesToHash(acc.KeccakCodeHash))
 				return errors.New("missing code")
 			}
 			codes += 1
@@ -496,8 +496,8 @@ func traverseRawState(ctx *cli.Context) error {
 					return storageIter.Error()
 				}
 			}
-			if !bytes.Equal(acc.CodeHash, types.EmptyCodeHash.Bytes()) {
-				if !rawdb.HasCode(chaindb, common.BytesToHash(acc.CodeHash)) {
+			if !bytes.Equal(acc.KeccakCodeHash, types.EmptyKeccakCodeHash.Bytes()) {
+				if !rawdb.HasCode(chaindb, common.BytesToHash(acc.KeccakCodeHash)) {
 					log.Error("Code is missing", "account", common.BytesToHash(accIter.LeafKey()))
 					return errors.New("missing code")
 				}
@@ -568,14 +568,15 @@ func dumpState(ctx *cli.Context) error {
 			return err
 		}
 		da := &state.DumpAccount{
-			Balance:   account.Balance.String(),
-			Nonce:     account.Nonce,
-			Root:      account.Root.Bytes(),
-			CodeHash:  account.CodeHash,
-			SecureKey: accIt.Hash().Bytes(),
+			Balance:          account.Balance.String(),
+			Nonce:            account.Nonce,
+			Root:             account.Root.Bytes(),
+			KeccakCodeHash:   account.KeccakCodeHash,
+			PoseidonCodeHash: account.PoseidonCodeHash,
+			SecureKey:        accIt.Hash().Bytes(),
 		}
-		if !conf.SkipCode && !bytes.Equal(account.CodeHash, types.EmptyCodeHash.Bytes()) {
-			da.Code = rawdb.ReadCode(db, common.BytesToHash(account.CodeHash))
+		if !conf.SkipCode && !bytes.Equal(account.KeccakCodeHash, types.EmptyKeccakCodeHash.Bytes()) {
+			da.Code = rawdb.ReadCode(db, common.BytesToHash(account.KeccakCodeHash))
 		}
 		if !conf.SkipStorage {
 			da.Storage = make(map[common.Hash]string)

core/state/dump.go

@@ -49,14 +49,15 @@ type DumpCollector interface {
 
 // DumpAccount represents an account in the state.
 type DumpAccount struct {
-	Balance   string                 `json:"balance"`
-	Nonce     uint64                 `json:"nonce"`
-	Root      hexutil.Bytes          `json:"root"`
-	CodeHash  hexutil.Bytes          `json:"codeHash"`
-	Code      hexutil.Bytes          `json:"code,omitempty"`
-	Storage   map[common.Hash]string `json:"storage,omitempty"`
-	Address   *common.Address        `json:"address,omitempty"` // Address only present in iterative (line-by-line) mode
-	SecureKey hexutil.Bytes          `json:"key,omitempty"`     // If we don't have address, we can output the key
+	Balance          string                 `json:"balance"`
+	Nonce            uint64                 `json:"nonce"`
+	Root             hexutil.Bytes          `json:"root"`
+	KeccakCodeHash   hexutil.Bytes          `json:"keccakCodeHash"`
+	PoseidonCodeHash hexutil.Bytes          `json:"poseidonCodeHash"`
+	Code             hexutil.Bytes          `json:"code,omitempty"`
+	Storage          map[common.Hash]string `json:"storage,omitempty"`
+	Address          *common.Address        `json:"address,omitempty"` // Address only present in iterative (line-by-line) mode
+	SecureKey        hexutil.Bytes          `json:"key,omitempty"`     // If we don't have address, we can output the key
 
 }
 
@@ -105,14 +106,15 @@ type iterativeDump struct {
 // OnAccount implements DumpCollector interface
 func (d iterativeDump) OnAccount(addr *common.Address, account DumpAccount) {
 	dumpAccount := &DumpAccount{
-		Balance:   account.Balance,
-		Nonce:     account.Nonce,
-		Root:      account.Root,
-		CodeHash:  account.CodeHash,
-		Code:      account.Code,
-		Storage:   account.Storage,
-		SecureKey: account.SecureKey,
-		Address:   addr,
+		Balance:          account.Balance,
+		Nonce:            account.Nonce,
+		Root:             account.Root,
+		KeccakCodeHash:   account.KeccakCodeHash,
+		PoseidonCodeHash: account.PoseidonCodeHash,
+		Code:             account.Code,
+		Storage:          account.Storage,
+		SecureKey:        account.SecureKey,
+		Address:          addr,
 	}
 	d.Encode(dumpAccount)
 }
@@ -151,11 +153,12 @@ func (s *StateDB) DumpToCollector(c DumpCollector, conf *DumpConfig) (nextKey []
 			panic(err)
 		}
 		account := DumpAccount{
-			Balance:   data.Balance.String(),
-			Nonce:     data.Nonce,
-			Root:      data.Root[:],
-			CodeHash:  data.CodeHash,
-			SecureKey: it.Key,
+			Balance:          data.Balance.String(),
+			Nonce:            data.Nonce,
+			Root:             data.Root[:],
+			KeccakCodeHash:   data.KeccakCodeHash,
+			PoseidonCodeHash: data.PoseidonCodeHash,
+			SecureKey:        it.Key,
 		}
 		var (
 			addrBytes = s.trie.GetKey(it.Key)

core/state/iterator.go

@@ -134,11 +134,11 @@ func (it *nodeIterator) step() error {
 	if !it.dataIt.Next(true) {
 		it.dataIt = nil
 	}
-	if !bytes.Equal(account.CodeHash, types.EmptyCodeHash.Bytes()) {
-		it.codeHash = common.BytesToHash(account.CodeHash)
-		it.code, err = it.state.db.ContractCode(address, common.BytesToHash(account.CodeHash))
+	if !bytes.Equal(account.KeccakCodeHash, types.EmptyKeccakCodeHash.Bytes()) {
+		it.codeHash = common.BytesToHash(account.KeccakCodeHash)
+		it.code, err = it.state.db.ContractCode(address, common.BytesToHash(account.KeccakCodeHash))
 		if err != nil {
-			return fmt.Errorf("code %x: %v", account.CodeHash, err)
+			return fmt.Errorf("code %x: %v", account.KeccakCodeHash, err)
 		}
 	}
 	it.accountHash = it.stateIt.Parent()

core/state/journal.go

@@ -222,7 +222,7 @@ func (ch nonceChange) dirtied() *common.Address {
 }
 
 func (ch codeChange) revert(s *StateDB) {
-	s.getStateObject(*ch.account).setCode(common.BytesToHash(ch.prevhash), ch.prevcode)
+	s.getStateObject(*ch.account).setCode(ch.prevcode)
 }
 
 func (ch codeChange) dirtied() *common.Address {

core/state/pruner/pruner.go

@@ -451,8 +451,8 @@ func extractGenesis(db ethdb.Database, stateBloom *stateBloom) error {
 					return storageIter.Error()
 				}
 			}
-			if !bytes.Equal(acc.CodeHash, types.EmptyCodeHash.Bytes()) {
-				stateBloom.Put(acc.CodeHash, nil)
+			if !bytes.Equal(acc.KeccakCodeHash, types.EmptyKeccakCodeHash.Bytes()) {
+				stateBloom.Put(acc.KeccakCodeHash, nil)
 			}
 		}
 	}

core/state/snapshot/conversion.go

@@ -74,7 +74,7 @@ func GenerateTrie(snaptree *Tree, root common.Hash, src ethdb.Database, dst ethd
 	scheme := snaptree.triedb.Scheme()
 	got, err := generateTrieRoot(dst, scheme, acctIt, common.Hash{}, stackTrieGenerate, func(dst ethdb.KeyValueWriter, accountHash, codeHash common.Hash, stat *generateStats) (common.Hash, error) {
 		// Migrate the code first, commit the contract code into the tmp db.
-		if codeHash != types.EmptyCodeHash {
+		if codeHash != types.EmptyKeccakCodeHash {
 			code := rawdb.ReadCode(src, codeHash)
 			if len(code) == 0 {
 				return common.Hash{}, errors.New("failed to read contract code")
@@ -317,7 +317,7 @@ func generateTrieRoot(db ethdb.KeyValueWriter, scheme string, it Iterator, accou
 					return stop(err)
 				}
 				go func(hash common.Hash) {
-					subroot, err := leafCallback(db, hash, common.BytesToHash(account.CodeHash), stats)
+					subroot, err := leafCallback(db, hash, common.BytesToHash(account.KeccakCodeHash), stats)
 					if err != nil {
 						results <- err
 						return

core/state/snapshot/generate.go

@@ -586,8 +586,11 @@ func generateAccounts(ctx *generatorContext, dl *diskLayer, accMarker []byte) er
 		if accMarker == nil || !bytes.Equal(account[:], accMarker) {
 			dataLen := len(val) // Approximate size, saves us a round of RLP-encoding
 			if !write {
-				if bytes.Equal(acc.CodeHash, types.EmptyCodeHash[:]) {
-					dataLen -= 32
+				if bytes.Equal(acc.KeccakCodeHash, types.EmptyKeccakCodeHash[:]) {
+					// TODO: codesize
+					// dataLen = dataLen - 32 - 32 - 8
+					// account for keccakCodeHash, poseidonCodeHash
+					dataLen = dataLen - 32 - 32
 				}
 				if acc.Root == types.EmptyRootHash {
 					dataLen -= 32