woop/core/rawdb/accessors_state.go

// Copyright 2020 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// The go-ethereum library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

package rawdb

import (
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/ethdb"
	"github.com/harmony-one/harmony/internal/utils"
)

// ReadPreimage retrieves a single preimage of the provided hash.
func ReadPreimage(db ethdb.KeyValueReader, hash common.Hash) []byte {
	data, _ := db.Get(preimageKey(hash))
	return data
}

// WritePreimages writes the provided set of preimages to the database.
func WritePreimages(db ethdb.KeyValueWriter, preimages map[common.Hash][]byte) error {
	for hash, preimage := range preimages {
		if err := db.Put(preimageKey(hash), preimage); err != nil {
			utils.Logger().Error().Err(err).Msg("Failed to store trie preimage")
		}
	}
	preimageCounter.Inc(int64(len(preimages)))
	preimageHitCounter.Inc(int64(len(preimages)))
	return nil
}

// ReadCode retrieves the contract code of the provided code hash.
func ReadCode(db ethdb.KeyValueReader, hash common.Hash) []byte {
	// Try with the prefixed code scheme first, if not then try with legacy
	// scheme.
	data := ReadCodeWithPrefix(db, hash)
	if len(data) != 0 {
		return data
	}
	data, _ = db.Get(hash.Bytes())
	return data
}

// ReadCodeWithPrefix retrieves the contract code of the provided code hash.
// The main difference between this function and ReadCode is this function
// will only check the existence with latest scheme(with prefix).
func ReadCodeWithPrefix(db ethdb.KeyValueReader, hash common.Hash) []byte {
	data, _ := db.Get(codeKey(hash))
	return data
}

// HasCode checks if the contract code corresponding to the
// provided code hash is present in the db.
func HasCode(db ethdb.KeyValueReader, hash common.Hash) bool {
	// Try with the prefixed code scheme first, if not then try with legacy
	// scheme.
	if ok := HasCodeWithPrefix(db, hash); ok {
		return true
	}
	ok, _ := db.Has(hash.Bytes())
	return ok
}

// HasCodeWithPrefix checks if the contract code corresponding to the
// provided code hash is present in the db. This function will only check
// presence using the prefix-scheme.
func HasCodeWithPrefix(db ethdb.KeyValueReader, hash common.Hash) bool {
	ok, _ := db.Has(codeKey(hash))
	return ok
}

// WriteCode writes the provided contract code database.
func WriteCode(db ethdb.KeyValueWriter, hash common.Hash, code []byte) {
	if err := db.Put(codeKey(hash), code); err != nil {
		utils.Logger().Error().Err(err).Msg("Failed to store contract code")
	}
}

// DeleteCode deletes the specified contract code from the database.
func DeleteCode(db ethdb.KeyValueWriter, hash common.Hash) {
	if err := db.Delete(codeKey(hash)); err != nil {
		utils.Logger().Error().Err(err).Msg("Failed to delete contract code")
	}
}

// ReadValidatorCode retrieves the validator code of the provided code hash.
func ReadValidatorCode(db ethdb.KeyValueReader, hash common.Hash) []byte {
	// Try with the prefixed code scheme first, if not then try with legacy
	// scheme.
	data := ReadValidatorCodeWithPrefix(db, hash)
	if len(data) != 0 {
		return data
	}
	data, _ = db.Get(hash.Bytes())
	return data
}

// ReadValidatorCodeWithPrefix retrieves the validator code of the provided code hash.
// The main difference between this function and ReadValidatorCode is this function
// will only check the existence with latest scheme(with prefix).
func ReadValidatorCodeWithPrefix(db ethdb.KeyValueReader, hash common.Hash) []byte {
	data, _ := db.Get(validatorCodeKey(hash))
	return data
}

// HasValidatorCode checks if the validator code corresponding to the
// provided code hash is present in the db.
func HasValidatorCode(db ethdb.KeyValueReader, hash common.Hash) bool {
	// Try with the prefixed code scheme first, if not then try with legacy
	// scheme.
	if ok := HasValidatorCodeWithPrefix(db, hash); ok {
		return true
	}
	ok, _ := db.Has(hash.Bytes())
	return ok
}

// HasValidatorCodeWithPrefix checks if the validator code corresponding to the
// provided code hash is present in the db. This function will only check
// presence using the prefix-scheme.
func HasValidatorCodeWithPrefix(db ethdb.KeyValueReader, hash common.Hash) bool {
	ok, _ := db.Has(validatorCodeKey(hash))
	return ok
}

// WriteValidatorCode writes the provided validator code to database.
func WriteValidatorCode(db ethdb.KeyValueWriter, hash common.Hash, code []byte) {
	if err := db.Put(validatorCodeKey(hash), code); err != nil {
		utils.Logger().Error().Err(err).Msg("Failed to store validator code")
	}
}

// DeleteValidatorCode deletes the specified validator code from the database.
func DeleteValidatorCode(db ethdb.KeyValueWriter, hash common.Hash) {
	if err := db.Delete(validatorCodeKey(hash)); err != nil {
		utils.Logger().Error().Err(err).Msg("Failed to delete validator code")
	}
}

func WritePreimageImportBlock(db ethdb.KeyValueWriter, number uint64) error {
	return db.Put(preImageImportKey, encodeBlockNumber(number))
}

func ReadPreimageImportBlock(db ethdb.KeyValueReader) (uint64, error) {
	val, err := db.Get(preImageImportKey)
	if err != nil {
		return 0, err
	}
	return decodeBlockNumber(val), nil
}

func WritePreImageStartEndBlock(
	db ethdb.KeyValueStore,
	start uint64,
	end uint64,
) (
	uint64,
	uint64,
	error,
) {
	returnStart := start
	returnEnd := end
	if start != 0 {
		existingStart, err := ReadPreImageStartBlock(db)
		if err != nil || existingStart > start {
			if err := db.Put(preImageGenStartKey, encodeBlockNumber(start)); err != nil {
				return 0, 0, err
			} else {
				returnStart = existingStart
			}
		}
	}
	if end != 0 {
		existingEnd, err := ReadPreImageEndBlock(db)
		if err != nil || existingEnd < end {
			if err := db.Put(preImageGenEndKey, encodeBlockNumber(end)); err != nil {
				return 0, 0, err
			} else {
				returnEnd = existingEnd
			}
		}
	}
	return returnStart, returnEnd, nil
}

func ReadPreImageStartBlock(db ethdb.KeyValueReader) (uint64, error) {
	val, err := db.Get(preImageGenStartKey)
	if err != nil {
		return 0, err
	}
	return decodeBlockNumber(val), nil
}

func ReadPreImageEndBlock(db ethdb.KeyValueReader) (uint64, error) {
	val, err := db.Get(preImageGenEndKey)
	if err != nil {
		return 0, err
	}
	return decodeBlockNumber(val), nil
}