db4cee7eac
* add filter types for block, pending tx, log * implement pollForBlocks for block filters * implement getFilterChanges for block filter * implement uninstall filter by stopping polling
374 lines
14 KiB
Go
374 lines
14 KiB
Go
package keeper
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/binary"
|
|
"errors"
|
|
"fmt"
|
|
|
|
"github.com/cosmos/cosmos-sdk/codec"
|
|
ethcmn "github.com/ethereum/go-ethereum/common"
|
|
ethvm "github.com/ethereum/go-ethereum/core/vm"
|
|
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
"github.com/cosmos/ethermint/x/evm/types"
|
|
ethstate "github.com/ethereum/go-ethereum/core/state"
|
|
ethtypes "github.com/ethereum/go-ethereum/core/types"
|
|
|
|
"math/big"
|
|
)
|
|
|
|
// Keeper wraps the CommitStateDB, allowing us to pass in SDK context while adhering
|
|
// to the StateDB interface.
|
|
type Keeper struct {
|
|
// Amino codec
|
|
cdc *codec.Codec
|
|
// Store key required to update the block bloom filter mappings needed for the
|
|
// Web3 API
|
|
blockKey sdk.StoreKey
|
|
CommitStateDB *types.CommitStateDB
|
|
TxCount int
|
|
Bloom *big.Int
|
|
}
|
|
|
|
// NewKeeper generates new evm module keeper
|
|
func NewKeeper(
|
|
cdc *codec.Codec, blockKey, codeKey, storeKey sdk.StoreKey,
|
|
ak types.AccountKeeper,
|
|
) Keeper {
|
|
return Keeper{
|
|
cdc: cdc,
|
|
blockKey: blockKey,
|
|
CommitStateDB: types.NewCommitStateDB(sdk.Context{}, codeKey, storeKey, ak),
|
|
TxCount: 0,
|
|
Bloom: big.NewInt(0),
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Block hash mapping functions
|
|
// May be removed when using only as module (only required by rpc api)
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// SetBlockHashMapping sets the mapping from block consensus hash to block height
|
|
func (k *Keeper) SetBlockHashMapping(ctx sdk.Context, hash []byte, height int64) {
|
|
store := ctx.KVStore(k.blockKey)
|
|
if !bytes.Equal(hash, []byte{}) {
|
|
bz := sdk.Uint64ToBigEndian(uint64(height))
|
|
store.Set(hash, bz)
|
|
}
|
|
}
|
|
|
|
// GetBlockHashMapping gets block height from block consensus hash
|
|
func (k *Keeper) GetBlockHashMapping(ctx sdk.Context, hash []byte) (height int64) {
|
|
store := ctx.KVStore(k.blockKey)
|
|
bz := store.Get(hash)
|
|
if bytes.Equal(bz, []byte{}) {
|
|
panic(fmt.Errorf("block with hash %s not found", ethcmn.BytesToHash(hash)))
|
|
}
|
|
|
|
height = int64(binary.BigEndian.Uint64(bz))
|
|
return height
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Block bloom bits mapping functions
|
|
// May be removed when using only as module (only required by rpc api)
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// SetBlockBloomMapping sets the mapping from block height to bloom bits
|
|
func (k *Keeper) SetBlockBloomMapping(ctx sdk.Context, bloom ethtypes.Bloom, height int64) error {
|
|
store := ctx.KVStore(k.blockKey)
|
|
bz := sdk.Uint64ToBigEndian(uint64(height))
|
|
if len(bz) == 0 {
|
|
return fmt.Errorf("block with bloombits %v not found", bloom)
|
|
}
|
|
|
|
store.Set(types.BloomKey(bz), bloom.Bytes())
|
|
return nil
|
|
}
|
|
|
|
// GetBlockBloomMapping gets bloombits from block height
|
|
func (k *Keeper) GetBlockBloomMapping(ctx sdk.Context, height int64) (ethtypes.Bloom, error) {
|
|
store := ctx.KVStore(k.blockKey)
|
|
bz := sdk.Uint64ToBigEndian(uint64(height))
|
|
if len(bz) == 0 {
|
|
return ethtypes.BytesToBloom([]byte{}), fmt.Errorf("block with height %d not found", height)
|
|
}
|
|
|
|
bloom := store.Get(types.BloomKey(bz))
|
|
return ethtypes.BytesToBloom(bloom), nil
|
|
}
|
|
|
|
// SetBlockLogs sets the transaction's logs in the KVStore
|
|
func (k *Keeper) SetTransactionLogs(ctx sdk.Context, logs []*ethtypes.Log, hash []byte) error {
|
|
store := ctx.KVStore(k.blockKey)
|
|
encLogs, err := types.EncodeLogs(logs)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
store.Set(types.LogsKey(hash), encLogs)
|
|
|
|
return nil
|
|
}
|
|
|
|
// GetBlockLogs gets the logs for a transaction from the KVStore
|
|
func (k *Keeper) GetTransactionLogs(ctx sdk.Context, hash []byte) ([]*ethtypes.Log, error) {
|
|
store := ctx.KVStore(k.blockKey)
|
|
encLogs := store.Get(types.LogsKey(hash))
|
|
if len(encLogs) == 0 {
|
|
return nil, errors.New("cannot get transaction logs")
|
|
}
|
|
|
|
return types.DecodeLogs(encLogs)
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Genesis
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// CreateGenesisAccount initializes an account and its balance, code, and storage
|
|
func (k *Keeper) CreateGenesisAccount(ctx sdk.Context, account types.GenesisAccount) {
|
|
csdb := k.CommitStateDB.WithContext(ctx)
|
|
csdb.SetBalance(account.Address, account.Balance)
|
|
csdb.SetCode(account.Address, account.Code)
|
|
for _, key := range account.Storage {
|
|
csdb.SetState(account.Address, key, account.Storage[key])
|
|
}
|
|
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Setters
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// SetBalance calls CommitStateDB.SetBalance using the passed in context
|
|
func (k *Keeper) SetBalance(ctx sdk.Context, addr ethcmn.Address, amount *big.Int) {
|
|
k.CommitStateDB.WithContext(ctx).SetBalance(addr, amount)
|
|
}
|
|
|
|
// AddBalance calls CommitStateDB.AddBalance using the passed in context
|
|
func (k *Keeper) AddBalance(ctx sdk.Context, addr ethcmn.Address, amount *big.Int) {
|
|
k.CommitStateDB.WithContext(ctx).AddBalance(addr, amount)
|
|
}
|
|
|
|
// SubBalance calls CommitStateDB.SubBalance using the passed in context
|
|
func (k *Keeper) SubBalance(ctx sdk.Context, addr ethcmn.Address, amount *big.Int) {
|
|
k.CommitStateDB.WithContext(ctx).SubBalance(addr, amount)
|
|
}
|
|
|
|
// SetNonce calls CommitStateDB.SetNonce using the passed in context
|
|
func (k *Keeper) SetNonce(ctx sdk.Context, addr ethcmn.Address, nonce uint64) {
|
|
k.CommitStateDB.WithContext(ctx).SetNonce(addr, nonce)
|
|
}
|
|
|
|
// SetState calls CommitStateDB.SetState using the passed in context
|
|
func (k *Keeper) SetState(ctx sdk.Context, addr ethcmn.Address, key, value ethcmn.Hash) {
|
|
k.CommitStateDB.WithContext(ctx).SetState(addr, key, value)
|
|
}
|
|
|
|
// SetCode calls CommitStateDB.SetCode using the passed in context
|
|
func (k *Keeper) SetCode(ctx sdk.Context, addr ethcmn.Address, code []byte) {
|
|
k.CommitStateDB.WithContext(ctx).SetCode(addr, code)
|
|
}
|
|
|
|
// AddLog calls CommitStateDB.AddLog using the passed in context
|
|
func (k *Keeper) AddLog(ctx sdk.Context, log *ethtypes.Log) {
|
|
k.CommitStateDB.WithContext(ctx).AddLog(log)
|
|
}
|
|
|
|
// AddPreimage calls CommitStateDB.AddPreimage using the passed in context
|
|
func (k *Keeper) AddPreimage(ctx sdk.Context, hash ethcmn.Hash, preimage []byte) {
|
|
k.CommitStateDB.WithContext(ctx).AddPreimage(hash, preimage)
|
|
}
|
|
|
|
// AddRefund calls CommitStateDB.AddRefund using the passed in context
|
|
func (k *Keeper) AddRefund(ctx sdk.Context, gas uint64) {
|
|
k.CommitStateDB.WithContext(ctx).AddRefund(gas)
|
|
}
|
|
|
|
// SubRefund calls CommitStateDB.SubRefund using the passed in context
|
|
func (k *Keeper) SubRefund(ctx sdk.Context, gas uint64) {
|
|
k.CommitStateDB.WithContext(ctx).SubRefund(gas)
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Getters
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// GetBalance calls CommitStateDB.GetBalance using the passed in context
|
|
func (k *Keeper) GetBalance(ctx sdk.Context, addr ethcmn.Address) *big.Int {
|
|
return k.CommitStateDB.WithContext(ctx).GetBalance(addr)
|
|
}
|
|
|
|
// GetNonce calls CommitStateDB.GetNonce using the passed in context
|
|
func (k *Keeper) GetNonce(ctx sdk.Context, addr ethcmn.Address) uint64 {
|
|
return k.CommitStateDB.WithContext(ctx).GetNonce(addr)
|
|
}
|
|
|
|
// TxIndex calls CommitStateDB.TxIndex using the passed in context
|
|
func (k *Keeper) TxIndex(ctx sdk.Context) int {
|
|
return k.CommitStateDB.WithContext(ctx).TxIndex()
|
|
}
|
|
|
|
// BlockHash calls CommitStateDB.BlockHash using the passed in context
|
|
func (k *Keeper) BlockHash(ctx sdk.Context) ethcmn.Hash {
|
|
return k.CommitStateDB.WithContext(ctx).BlockHash()
|
|
}
|
|
|
|
// GetCode calls CommitStateDB.GetCode using the passed in context
|
|
func (k *Keeper) GetCode(ctx sdk.Context, addr ethcmn.Address) []byte {
|
|
return k.CommitStateDB.WithContext(ctx).GetCode(addr)
|
|
}
|
|
|
|
// GetCodeSize calls CommitStateDB.GetCodeSize using the passed in context
|
|
func (k *Keeper) GetCodeSize(ctx sdk.Context, addr ethcmn.Address) int {
|
|
return k.CommitStateDB.WithContext(ctx).GetCodeSize(addr)
|
|
}
|
|
|
|
// GetCodeHash calls CommitStateDB.GetCodeHash using the passed in context
|
|
func (k *Keeper) GetCodeHash(ctx sdk.Context, addr ethcmn.Address) ethcmn.Hash {
|
|
return k.CommitStateDB.WithContext(ctx).GetCodeHash(addr)
|
|
}
|
|
|
|
// GetState calls CommitStateDB.GetState using the passed in context
|
|
func (k *Keeper) GetState(ctx sdk.Context, addr ethcmn.Address, hash ethcmn.Hash) ethcmn.Hash {
|
|
return k.CommitStateDB.WithContext(ctx).GetState(addr, hash)
|
|
}
|
|
|
|
// GetCommittedState calls CommitStateDB.GetCommittedState using the passed in context
|
|
func (k *Keeper) GetCommittedState(ctx sdk.Context, addr ethcmn.Address, hash ethcmn.Hash) ethcmn.Hash {
|
|
return k.CommitStateDB.WithContext(ctx).GetCommittedState(addr, hash)
|
|
}
|
|
|
|
// GetLogs calls CommitStateDB.GetLogs using the passed in context
|
|
func (k *Keeper) GetLogs(ctx sdk.Context, hash ethcmn.Hash) ([]*ethtypes.Log, error) {
|
|
logs, err := k.CommitStateDB.WithContext(ctx).GetLogs(hash)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return logs, nil
|
|
}
|
|
|
|
// AllLogs calls CommitStateDB.AllLogs using the passed in context
|
|
func (k *Keeper) AllLogs(ctx sdk.Context) []*ethtypes.Log {
|
|
return k.CommitStateDB.WithContext(ctx).AllLogs()
|
|
}
|
|
|
|
// GetRefund calls CommitStateDB.GetRefund using the passed in context
|
|
func (k *Keeper) GetRefund(ctx sdk.Context) uint64 {
|
|
return k.CommitStateDB.WithContext(ctx).GetRefund()
|
|
}
|
|
|
|
// Preimages calls CommitStateDB.Preimages using the passed in context
|
|
func (k *Keeper) Preimages(ctx sdk.Context) map[ethcmn.Hash][]byte {
|
|
return k.CommitStateDB.WithContext(ctx).Preimages()
|
|
}
|
|
|
|
// HasSuicided calls CommitStateDB.HasSuicided using the passed in context
|
|
func (k *Keeper) HasSuicided(ctx sdk.Context, addr ethcmn.Address) bool {
|
|
return k.CommitStateDB.WithContext(ctx).HasSuicided(addr)
|
|
}
|
|
|
|
// StorageTrie calls CommitStateDB.StorageTrie using the passed in context
|
|
func (k *Keeper) StorageTrie(ctx sdk.Context, addr ethcmn.Address) ethstate.Trie {
|
|
return k.CommitStateDB.WithContext(ctx).StorageTrie(addr)
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Persistence
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Commit calls CommitStateDB.Commit using the passed { in context
|
|
func (k *Keeper) Commit(ctx sdk.Context, deleteEmptyObjects bool) (root ethcmn.Hash, err error) {
|
|
return k.CommitStateDB.WithContext(ctx).Commit(deleteEmptyObjects)
|
|
}
|
|
|
|
// Finalise calls CommitStateDB.Finalise using the passed in context
|
|
func (k *Keeper) Finalise(ctx sdk.Context, deleteEmptyObjects bool) error {
|
|
return k.CommitStateDB.WithContext(ctx).Finalise(deleteEmptyObjects)
|
|
}
|
|
|
|
// IntermediateRoot calls CommitStateDB.IntermediateRoot using the passed in context
|
|
func (k *Keeper) IntermediateRoot(ctx sdk.Context, deleteEmptyObjects bool) error {
|
|
_, err := k.CommitStateDB.WithContext(ctx).IntermediateRoot(deleteEmptyObjects)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Snapshotting
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Snapshot calls CommitStateDB.Snapshot using the passed in context
|
|
func (k *Keeper) Snapshot(ctx sdk.Context) int {
|
|
return k.CommitStateDB.WithContext(ctx).Snapshot()
|
|
}
|
|
|
|
// RevertToSnapshot calls CommitStateDB.RevertToSnapshot using the passed in context
|
|
func (k *Keeper) RevertToSnapshot(ctx sdk.Context, revID int) {
|
|
k.CommitStateDB.WithContext(ctx).RevertToSnapshot(revID)
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Auxiliary
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Database calls CommitStateDB.Database using the passed in context
|
|
func (k *Keeper) Database(ctx sdk.Context) ethstate.Database {
|
|
return k.CommitStateDB.WithContext(ctx).Database()
|
|
}
|
|
|
|
// Empty calls CommitStateDB.Empty using the passed in context
|
|
func (k *Keeper) Empty(ctx sdk.Context, addr ethcmn.Address) bool {
|
|
return k.CommitStateDB.WithContext(ctx).Empty(addr)
|
|
}
|
|
|
|
// Exist calls CommitStateDB.Exist using the passed in context
|
|
func (k *Keeper) Exist(ctx sdk.Context, addr ethcmn.Address) bool {
|
|
return k.CommitStateDB.WithContext(ctx).Exist(addr)
|
|
}
|
|
|
|
// Error calls CommitStateDB.Error using the passed in context
|
|
func (k *Keeper) Error(ctx sdk.Context) error {
|
|
return k.CommitStateDB.WithContext(ctx).Error()
|
|
}
|
|
|
|
// Suicide calls CommitStateDB.Suicide using the passed in context
|
|
func (k *Keeper) Suicide(ctx sdk.Context, addr ethcmn.Address) bool {
|
|
return k.CommitStateDB.WithContext(ctx).Suicide(addr)
|
|
}
|
|
|
|
// Reset calls CommitStateDB.Reset using the passed in context
|
|
func (k *Keeper) Reset(ctx sdk.Context, root ethcmn.Hash) error {
|
|
return k.CommitStateDB.WithContext(ctx).Reset(root)
|
|
}
|
|
|
|
// Prepare calls CommitStateDB.Prepare using the passed in context
|
|
func (k *Keeper) Prepare(ctx sdk.Context, thash, bhash ethcmn.Hash, txi int) {
|
|
k.CommitStateDB.WithContext(ctx).Prepare(thash, bhash, txi)
|
|
}
|
|
|
|
// CreateAccount calls CommitStateDB.CreateAccount using the passed in context
|
|
func (k *Keeper) CreateAccount(ctx sdk.Context, addr ethcmn.Address) {
|
|
k.CommitStateDB.WithContext(ctx).CreateAccount(addr)
|
|
}
|
|
|
|
// Copy calls CommitStateDB.Copy using the passed in context
|
|
func (k *Keeper) Copy(ctx sdk.Context) ethvm.StateDB {
|
|
return k.CommitStateDB.WithContext(ctx).Copy()
|
|
}
|
|
|
|
// ForEachStorage calls CommitStateDB.ForEachStorage using passed in context
|
|
func (k *Keeper) ForEachStorage(ctx sdk.Context, addr ethcmn.Address, cb func(key, value ethcmn.Hash) bool) error {
|
|
return k.CommitStateDB.WithContext(ctx).ForEachStorage(addr, cb)
|
|
}
|
|
|
|
// GetOrNewStateObject calls CommitStateDB.GetOrNetStateObject using the passed in context
|
|
func (k *Keeper) GetOrNewStateObject(ctx sdk.Context, addr ethcmn.Address) types.StateObject {
|
|
return k.CommitStateDB.WithContext(ctx).GetOrNewStateObject(addr)
|
|
}
|