mirror/erigon-pulse
1
0
Fork 0
mirror of https://gitlab.com/pulsechaincom/erigon-pulse.git synced 2024-12-21 19:20:39 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

move math big constants to erigon-lib (#6719)

Browse Source
This commit is contained in:
Alex Sharov 2023-01-27 11:39:34 +07:00 committed by GitHub
parent 081e59311d
commit b99e4abb3e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
66 changed files with 409 additions and 436 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
accounts/abi/pack.go
View File

@ -22,6 +22,7 @@ import (
"math/big"
"reflect"
common2 "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon/common"
"github.com/ledgerwatch/erigon/common/math"
)
@ -49,9 +50,9 @@ func packElement(t Type, reflectValue reflect.Value) ([]byte, error) {
return common.LeftPadBytes(reflectValue.Bytes(), 32), nil
case BoolTy:
if reflectValue.Bool() {
return math.PaddedBigBytes(common.Big1, 32), nil
return math.PaddedBigBytes(common2.Big1, 32), nil
}
return math.PaddedBigBytes(common.Big0, 32), nil
return math.PaddedBigBytes(common2.Big0, 32), nil
case BytesTy:
if reflectValue.Kind() == reflect.Array {
reflectValue = mustArrayToByteSlice(reflectValue)

10
accounts/abi/unpack.go
View File

@ -23,15 +23,13 @@ import (
"reflect"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon/common"
)
var (
// MaxUint256 is the maximum value that can be represented by a uint256.
MaxUint256 = new(big.Int).Sub(new(big.Int).Lsh(common.Big1, 256), common.Big1)
MaxUint256 = new(big.Int).Sub(new(big.Int).Lsh(libcommon.Big1, 256), libcommon.Big1)
// MaxInt256 is the maximum value that can be represented by a int256.
MaxInt256 = new(big.Int).Sub(new(big.Int).Lsh(common.Big1, 255), common.Big1)
MaxInt256 = new(big.Int).Sub(new(big.Int).Lsh(libcommon.Big1, 255), libcommon.Big1)
)
// ReadInteger reads the integer based on its kind and returns the appropriate value.
@ -68,7 +66,7 @@ func ReadInteger(typ Type, b []byte) interface{} {
ret := new(big.Int).SetBytes(b)
if ret.Bit(255) == 1 {
ret.Add(MaxUint256, new(big.Int).Neg(ret))
ret.Add(ret, common.Big1)
ret.Add(ret, libcommon.Big1)
ret.Neg(ret)
}
return ret
@ -258,7 +256,7 @@ func toGoType(index int, t Type, output []byte) (interface{}, error) {
// lengthPrefixPointsTo interprets a 32 byte slice as an offset and then determines which indices to look to decode the type.
func lengthPrefixPointsTo(index int, output []byte) (start int, length int, err error) {
bigOffsetEnd := big.NewInt(0).SetBytes(output[index : index+32])
bigOffsetEnd.Add(bigOffsetEnd, common.Big32)
bigOffsetEnd.Add(bigOffsetEnd, libcommon.Big32)
outputLength := big.NewInt(int64(len(output)))
if bigOffsetEnd.Cmp(outputLength) > 0 {

2
cmd/devnet/contracts/gen_subscription.go
View File

@ -23,7 +23,7 @@ var (
_ = strings.NewReader
_ = ethereum.NotFound
_ = bind.Bind
_ = common.Big1
_ = libcommon.Big1
_ = types.BloomLookup
_ = event.NewSubscription
)

3
cmd/erigon-el/backend/backend.go
View File

@ -56,7 +56,6 @@ import (
"github.com/ledgerwatch/erigon/cmd/rpcdaemon/cli"
"github.com/ledgerwatch/erigon/cmd/rpcdaemon/commands"
"github.com/ledgerwatch/erigon/cmd/sentry/sentry"
"github.com/ledgerwatch/erigon/common"
"github.com/ledgerwatch/erigon/common/debug"
"github.com/ledgerwatch/erigon/consensus"
"github.com/ledgerwatch/erigon/consensus/bor"
@ -161,7 +160,7 @@ type Ethereum struct {
// New creates a new Ethereum object (including the
// initialisation of the common Ethereum object)
func NewBackend(stack *node.Node, config *ethconfig.Config, logger log.Logger) (*Ethereum, error) {
if config.Miner.GasPrice == nil || config.Miner.GasPrice.Cmp(common.Big0) <= 0 {
if config.Miner.GasPrice == nil || config.Miner.GasPrice.Cmp(libcommon.Big0) <= 0 {
log.Warn("Sanitizing invalid miner gas price", "provided", config.Miner.GasPrice, "updated", ethconfig.Defaults.Miner.GasPrice)
config.Miner.GasPrice = new(big.Int).Set(ethconfig.Defaults.Miner.GasPrice)
}

2
cmd/pics/contracts/gen_token.go
View File

@ -23,7 +23,7 @@ var (
_ = strings.NewReader
_ = ethereum.NotFound
_ = bind.Bind
_ = common.Big1
_ = libcommon.Big1
_ = types.BloomLookup
_ = event.NewSubscription
)

12
cmd/rpcdaemon/commands/bor_api.go
View File

@ -1,7 +1,7 @@
package commands
import (
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/kv"
"github.com/ledgerwatch/erigon/consensus/bor"
@ -12,11 +12,11 @@ import (
type BorAPI interface {
// Bor snapshot related (see ./bor_snapshot.go)
GetSnapshot(number *rpc.BlockNumber) (*Snapshot, error)
GetAuthor(number *rpc.BlockNumber) (*libcommon.Address, error)
GetSnapshotAtHash(hash libcommon.Hash) (*Snapshot, error)
GetSigners(number *rpc.BlockNumber) ([]libcommon.Address, error)
GetSignersAtHash(hash libcommon.Hash) ([]libcommon.Address, error)
GetCurrentProposer() (libcommon.Address, error)
GetAuthor(number *rpc.BlockNumber) (*common.Address, error)
GetSnapshotAtHash(hash common.Hash) (*Snapshot, error)
GetSigners(number *rpc.BlockNumber) ([]common.Address, error)
GetSignersAtHash(hash common.Hash) ([]common.Address, error)
GetCurrentProposer() (common.Address, error)
GetCurrentValidators() ([]*bor.Validator, error)
GetRootHash(start uint64, end uint64) (string, error)
}

14
cmd/rpcdaemon/commands/bor_helper.go
View File

@ -7,7 +7,7 @@ import (
"fmt"
"github.com/ledgerwatch/erigon-lib/chain"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/kv"
"github.com/ledgerwatch/erigon/consensus/bor"
@ -74,7 +74,7 @@ func getHeaderByNumber(ctx context.Context, number rpc.BlockNumber, api *BorImpl
// getHeaderByHash returns a block's header given a block's hash.
// derived from erigon_getHeaderByHash implementation (see ./erigon_block.go)
func getHeaderByHash(ctx context.Context, api *BorImpl, tx kv.Tx, hash libcommon.Hash) (*types.Header, error) {
func getHeaderByHash(ctx context.Context, api *BorImpl, tx kv.Tx, hash common.Hash) (*types.Header, error) {
header, err := api._blockReader.HeaderByHash(ctx, tx, hash)
if err != nil {
return nil, err
@ -87,19 +87,19 @@ func getHeaderByHash(ctx context.Context, api *BorImpl, tx kv.Tx, hash libcommon
}
// ecrecover extracts the Ethereum account address from a signed header.
func ecrecover(header *types.Header, c *chain.BorConfig) (libcommon.Address, error) {
func ecrecover(header *types.Header, c *chain.BorConfig) (common.Address, error) {
// Retrieve the signature from the header extra-data
if len(header.Extra) < extraSeal {
return libcommon.Address{}, errMissingSignature
return common.Address{}, errMissingSignature
}
signature := header.Extra[len(header.Extra)-extraSeal:]
// Recover the public key and the Ethereum address
pubkey, err := crypto.Ecrecover(bor.SealHash(header, c).Bytes(), signature)
if err != nil {
return libcommon.Address{}, err
return common.Address{}, err
}
var signer libcommon.Address
var signer common.Address
copy(signer[:], crypto.Keccak256(pubkey[1:])[12:])
return signer, nil
@ -155,7 +155,7 @@ func getUpdatedValidatorSet(oldValidatorSet *ValidatorSet, newVals []*bor.Valida
// author returns the Ethereum address recovered
// from the signature in the header's extra-data section.
func author(api *BorImpl, tx kv.Tx, header *types.Header) (libcommon.Address, error) {
func author(api *BorImpl, tx kv.Tx, header *types.Header) (common.Address, error) {
config, _ := api.BaseAPI.chainConfig(tx)
return ecrecover(header, config.Bor)
}

32
cmd/rpcdaemon/commands/bor_snapshot.go
View File

@ -8,7 +8,7 @@ import (
"math/big"
"github.com/ledgerwatch/erigon-lib/chain"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/kv"
"github.com/ledgerwatch/log/v3"
"github.com/xsleonard/go-merkle"
@ -25,10 +25,10 @@ import (
type Snapshot struct {
config *chain.BorConfig // Consensus engine parameters to fine tune behavior
Number uint64 `json:"number"` // Block number where the snapshot was created
Hash libcommon.Hash `json:"hash"` // Block hash where the snapshot was created
ValidatorSet *ValidatorSet `json:"validatorSet"` // Validator set at this moment
Recents map[uint64]libcommon.Address `json:"recents"` // Set of recent signers for spam protections
Number uint64 `json:"number"` // Block number where the snapshot was created
Hash common.Hash `json:"hash"` // Block hash where the snapshot was created
ValidatorSet *ValidatorSet `json:"validatorSet"` // Validator set at this moment
Recents map[uint64]common.Address `json:"recents"` // Set of recent signers for spam protections
}
// GetSnapshot retrieves the state snapshot at a given block.
@ -63,7 +63,7 @@ func (api *BorImpl) GetSnapshot(number *rpc.BlockNumber) (*Snapshot, error) {
}
// GetAuthor retrieves the author a block.
func (api *BorImpl) GetAuthor(number *rpc.BlockNumber) (*libcommon.Address, error) {
func (api *BorImpl) GetAuthor(number *rpc.BlockNumber) (*common.Address, error) {
ctx := context.Background()
tx, err := api.db.BeginRo(ctx)
if err != nil {
@ -87,7 +87,7 @@ func (api *BorImpl) GetAuthor(number *rpc.BlockNumber) (*libcommon.Address, erro
}
// GetSnapshotAtHash retrieves the state snapshot at a given block.
func (api *BorImpl) GetSnapshotAtHash(hash libcommon.Hash) (*Snapshot, error) {
func (api *BorImpl) GetSnapshotAtHash(hash common.Hash) (*Snapshot, error) {
// init chain db
ctx := context.Background()
tx, err := api.db.BeginRo(ctx)
@ -114,7 +114,7 @@ func (api *BorImpl) GetSnapshotAtHash(hash libcommon.Hash) (*Snapshot, error) {
}
// GetSigners retrieves the list of authorized signers at the specified block.
func (api *BorImpl) GetSigners(number *rpc.BlockNumber) ([]libcommon.Address, error) {
func (api *BorImpl) GetSigners(number *rpc.BlockNumber) ([]common.Address, error) {
// init chain db
ctx := context.Background()
tx, err := api.db.BeginRo(ctx)
@ -146,7 +146,7 @@ func (api *BorImpl) GetSigners(number *rpc.BlockNumber) ([]libcommon.Address, er
}
// GetSignersAtHash retrieves the list of authorized signers at the specified block.
func (api *BorImpl) GetSignersAtHash(hash libcommon.Hash) ([]libcommon.Address, error) {
func (api *BorImpl) GetSignersAtHash(hash common.Hash) ([]common.Address, error) {
// init chain db
ctx := context.Background()
tx, err := api.db.BeginRo(ctx)
@ -175,10 +175,10 @@ func (api *BorImpl) GetSignersAtHash(hash libcommon.Hash) ([]libcommon.Address,
}
// GetCurrentProposer gets the current proposer
func (api *BorImpl) GetCurrentProposer() (libcommon.Address, error) {
func (api *BorImpl) GetCurrentProposer() (common.Address, error) {
snap, err := api.GetSnapshot(nil)
if err != nil {
return libcommon.Address{}, err
return common.Address{}, err
}
return snap.ValidatorSet.GetProposer().Address, nil
}
@ -249,7 +249,7 @@ func (s *Snapshot) copy() *Snapshot {
Number: s.Number,
Hash: s.Hash,
ValidatorSet: s.ValidatorSet.Copy(),
Recents: make(map[uint64]libcommon.Address),
Recents: make(map[uint64]common.Address),
}
for block, signer := range s.Recents {
cpy.Recents[block] = signer
@ -259,7 +259,7 @@ func (s *Snapshot) copy() *Snapshot {
}
// GetSignerSuccessionNumber returns the relative position of signer in terms of the in-turn proposer
func (s *Snapshot) GetSignerSuccessionNumber(signer libcommon.Address) (int, error) {
func (s *Snapshot) GetSignerSuccessionNumber(signer common.Address) (int, error) {
validators := s.ValidatorSet.Validators
proposer := s.ValidatorSet.GetProposer().Address
proposerIndex, _ := s.ValidatorSet.GetByAddress(proposer)
@ -281,8 +281,8 @@ func (s *Snapshot) GetSignerSuccessionNumber(signer libcommon.Address) (int, err
}
// signers retrieves the list of authorized signers in ascending order.
func (s *Snapshot) signers() []libcommon.Address {
sigs := make([]libcommon.Address, 0, len(s.ValidatorSet.Validators))
func (s *Snapshot) signers() []common.Address {
sigs := make([]common.Address, 0, len(s.ValidatorSet.Validators))
for _, sig := range s.ValidatorSet.Validators {
sigs = append(sigs, sig.Address)
}
@ -405,7 +405,7 @@ func snapshot(ctx context.Context, api *BorImpl, db kv.Tx, borDb kv.Tx, header *
}
// loadSnapshot loads an existing snapshot from the database.
func loadSnapshot(api *BorImpl, db kv.Tx, borDb kv.Tx, hash libcommon.Hash) (*Snapshot, error) {
func loadSnapshot(api *BorImpl, db kv.Tx, borDb kv.Tx, hash common.Hash) (*Snapshot, error) {
blob, err := borDb.GetOne(kv.BorSeparate, append([]byte("bor-"), hash[:]...))
if err != nil {
return nil, err

42
cmd/rpcdaemon/commands/call_traces_test.go
View File

@ -7,7 +7,7 @@ import (
"github.com/holiman/uint256"
jsoniter "github.com/json-iterator/go"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/kv/kvcache"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
@ -47,7 +47,7 @@ func blockNumbersFromTraces(t *testing.T, b []byte) []int {
func TestCallTraceOneByOne(t *testing.T) {
m := stages.Mock(t)
chain, err := core.GenerateChain(m.ChainConfig, m.Genesis, m.Engine, m.DB, 10, func(i int, gen *core.BlockGen) {
gen.SetCoinbase(libcommon.Address{1})
gen.SetCoinbase(common.Address{1})
}, false /* intermediateHashes */)
if err != nil {
t.Fatalf("generate chain: %v", err)
@ -69,11 +69,11 @@ func TestCallTraceOneByOne(t *testing.T) {
var fromBlock, toBlock uint64
fromBlock = 1
toBlock = 10
toAddress1 := libcommon.Address{1}
toAddress1 := common.Address{1}
traceReq1 := TraceFilterRequest{
FromBlock: (*hexutil.Uint64)(&fromBlock),
ToBlock: (*hexutil.Uint64)(&toBlock),
ToAddress: []*libcommon.Address{&toAddress1},
ToAddress: []*common.Address{&toAddress1},
}
if err = api.Filter(context.Background(), traceReq1, stream); err != nil {
t.Fatalf("trace_filter failed: %v", err)
@ -86,16 +86,16 @@ func TestCallTraceUnwind(t *testing.T) {
var chainA, chainB *core.ChainPack
var err error
chainA, err = core.GenerateChain(m.ChainConfig, m.Genesis, m.Engine, m.DB, 10, func(i int, gen *core.BlockGen) {
gen.SetCoinbase(libcommon.Address{1})
gen.SetCoinbase(common.Address{1})
}, false /* intermediateHashes */)
if err != nil {
t.Fatalf("generate chainA: %v", err)
}
chainB, err = core.GenerateChain(m.ChainConfig, m.Genesis, m.Engine, m.DB, 20, func(i int, gen *core.BlockGen) {
if i < 5 || i >= 10 {
gen.SetCoinbase(libcommon.Address{1})
gen.SetCoinbase(common.Address{1})
} else {
gen.SetCoinbase(libcommon.Address{2})
gen.SetCoinbase(common.Address{2})
}
}, false /* intermediateHashes */)
if err != nil {
@ -113,11 +113,11 @@ func TestCallTraceUnwind(t *testing.T) {
var fromBlock, toBlock uint64
fromBlock = 1
toBlock = 10
toAddress1 := libcommon.Address{1}
toAddress1 := common.Address{1}
traceReq1 := TraceFilterRequest{
FromBlock: (*hexutil.Uint64)(&fromBlock),
ToBlock: (*hexutil.Uint64)(&toBlock),
ToAddress: []*libcommon.Address{&toAddress1},
ToAddress: []*common.Address{&toAddress1},
}
if err = api.Filter(context.Background(), traceReq1, stream); err != nil {
t.Fatalf("trace_filter failed: %v", err)
@ -132,7 +132,7 @@ func TestCallTraceUnwind(t *testing.T) {
traceReq2 := TraceFilterRequest{
FromBlock: (*hexutil.Uint64)(&fromBlock),
ToBlock: (*hexutil.Uint64)(&toBlock),
ToAddress: []*libcommon.Address{&toAddress1},
ToAddress: []*common.Address{&toAddress1},
}
if err = api.Filter(context.Background(), traceReq2, stream); err != nil {
t.Fatalf("trace_filter failed: %v", err)
@ -148,7 +148,7 @@ func TestCallTraceUnwind(t *testing.T) {
traceReq3 := TraceFilterRequest{
FromBlock: (*hexutil.Uint64)(&fromBlock),
ToBlock: (*hexutil.Uint64)(&toBlock),
ToAddress: []*libcommon.Address{&toAddress1},
ToAddress: []*common.Address{&toAddress1},
}
if err = api.Filter(context.Background(), traceReq3, stream); err != nil {
t.Fatalf("trace_filter failed: %v", err)
@ -159,7 +159,7 @@ func TestCallTraceUnwind(t *testing.T) {
func TestFilterNoAddresses(t *testing.T) {
m := stages.Mock(t)
chain, err := core.GenerateChain(m.ChainConfig, m.Genesis, m.Engine, m.DB, 10, func(i int, gen *core.BlockGen) {
gen.SetCoinbase(libcommon.Address{1})
gen.SetCoinbase(common.Address{1})
}, false /* intermediateHashes */)
if err != nil {
t.Fatalf("generate chain: %v", err)
@ -194,13 +194,13 @@ func TestFilterAddressIntersection(t *testing.T) {
br := snapshotsync.NewBlockReaderWithSnapshots(m.BlockSnapshots)
api := NewTraceAPI(NewBaseApi(nil, kvcache.New(kvcache.DefaultCoherentConfig), br, agg, false, rpccfg.DefaultEvmCallTimeout, m.Engine), m.DB, &httpcfg.HttpCfg{})
toAddress1, toAddress2, other := libcommon.Address{1}, libcommon.Address{2}, libcommon.Address{3}
toAddress1, toAddress2, other := common.Address{1}, common.Address{2}, common.Address{3}
once := new(sync.Once)
chain, err := core.GenerateChain(m.ChainConfig, m.Genesis, m.Engine, m.DB, 15, func(i int, block *core.BlockGen) {
once.Do(func() { block.SetCoinbase(libcommon.Address{4}) })
once.Do(func() { block.SetCoinbase(common.Address{4}) })
var rcv libcommon.Address
var rcv common.Address
if i < 5 {
rcv = toAddress1
} else if i < 10 {
@ -229,8 +229,8 @@ func TestFilterAddressIntersection(t *testing.T) {
traceReq1 := TraceFilterRequest{
FromBlock: (*hexutil.Uint64)(&fromBlock),
ToBlock: (*hexutil.Uint64)(&toBlock),
FromAddress: []*libcommon.Address{&m.Address, &other},
ToAddress: []*libcommon.Address{&m.Address, &toAddress2},
FromAddress: []*common.Address{&m.Address, &other},
ToAddress: []*common.Address{&m.Address, &toAddress2},
Mode: TraceFilterModeIntersection,
}
if err = api.Filter(context.Background(), traceReq1, stream); err != nil {
@ -245,8 +245,8 @@ func TestFilterAddressIntersection(t *testing.T) {
traceReq1 := TraceFilterRequest{
FromBlock: (*hexutil.Uint64)(&fromBlock),
ToBlock: (*hexutil.Uint64)(&toBlock),
FromAddress: []*libcommon.Address{&m.Address, &other},
ToAddress: []*libcommon.Address{&toAddress1, &m.Address},
FromAddress: []*common.Address{&m.Address, &other},
ToAddress: []*common.Address{&toAddress1, &m.Address},
Mode: TraceFilterModeIntersection,
}
if err = api.Filter(context.Background(), traceReq1, stream); err != nil {
@ -261,8 +261,8 @@ func TestFilterAddressIntersection(t *testing.T) {
traceReq1 := TraceFilterRequest{
FromBlock: (*hexutil.Uint64)(&fromBlock),
ToBlock: (*hexutil.Uint64)(&toBlock),
ToAddress: []*libcommon.Address{&other},
FromAddress: []*libcommon.Address{&toAddress2, &toAddress1, &other},
ToAddress: []*common.Address{&other},
FromAddress: []*common.Address{&toAddress2, &toAddress1, &other},
Mode: TraceFilterModeIntersection,
}
if err = api.Filter(context.Background(), traceReq1, stream); err != nil {

2
cmd/rpcdaemon/commands/contracts/gen_poly.go
View File

@ -23,7 +23,7 @@ var (
_ = strings.NewReader
_ = ethereum.NotFound
_ = bind.Bind
_ = common.Big1
_ = libcommon.Big1
_ = types.BloomLookup
_ = event.NewSubscription
)

2
cmd/rpcdaemon/commands/contracts/gen_token.go
View File

@ -23,7 +23,7 @@ var (
_ = strings.NewReader
_ = ethereum.NotFound
_ = bind.Bind
_ = common.Big1
_ = libcommon.Big1
_ = types.BloomLookup
_ = event.NewSubscription
)

10
cmd/rpcdaemon/commands/corner_cases_support_test.go
View File

@ -4,7 +4,7 @@ import (
"context"
"testing"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/kv/kvcache"
"github.com/stretchr/testify/require"
@ -31,7 +31,7 @@ func TestNotFoundMustReturnNil(t *testing.T) {
require.Nil(a)
require.Nil(err)
b, err := api.GetTransactionByBlockHashAndIndex(ctx, libcommon.Hash{}, 1)
b, err := api.GetTransactionByBlockHashAndIndex(ctx, common.Hash{}, 1)
require.Nil(b)
require.Nil(err)
@ -39,11 +39,11 @@ func TestNotFoundMustReturnNil(t *testing.T) {
require.Nil(c)
require.Nil(err)
d, err := api.GetTransactionReceipt(ctx, libcommon.Hash{})
d, err := api.GetTransactionReceipt(ctx, common.Hash{})
require.Nil(d)
require.Nil(err)
e, err := api.GetBlockByHash(ctx, rpc.BlockNumberOrHashWithHash(libcommon.Hash{}, true), false)
e, err := api.GetBlockByHash(ctx, rpc.BlockNumberOrHashWithHash(common.Hash{}, true), false)
require.Nil(e)
require.Nil(err)
@ -51,7 +51,7 @@ func TestNotFoundMustReturnNil(t *testing.T) {
require.Nil(f)
require.Nil(err)
g, err := api.GetUncleByBlockHashAndIndex(ctx, libcommon.Hash{}, 1)
g, err := api.GetUncleByBlockHashAndIndex(ctx, common.Hash{}, 1)
require.Nil(g)
require.Nil(err)

28
cmd/rpcdaemon/commands/debug_api.go
View File

@ -5,7 +5,7 @@ import (
"fmt"
jsoniter "github.com/json-iterator/go"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/kv"
"github.com/ledgerwatch/erigon-lib/kv/rawdbv3"
@ -25,15 +25,15 @@ const AccountRangeMaxResults = 256
// PrivateDebugAPI Exposed RPC endpoints for debugging use
type PrivateDebugAPI interface {
StorageRangeAt(ctx context.Context, blockHash libcommon.Hash, txIndex uint64, contractAddress libcommon.Address, keyStart hexutil.Bytes, maxResult int) (StorageRangeResult, error)
TraceTransaction(ctx context.Context, hash libcommon.Hash, config *tracers.TraceConfig, stream *jsoniter.Stream) error
TraceBlockByHash(ctx context.Context, hash libcommon.Hash, config *tracers.TraceConfig, stream *jsoniter.Stream) error
StorageRangeAt(ctx context.Context, blockHash common.Hash, txIndex uint64, contractAddress common.Address, keyStart hexutil.Bytes, maxResult int) (StorageRangeResult, error)
TraceTransaction(ctx context.Context, hash common.Hash, config *tracers.TraceConfig, stream *jsoniter.Stream) error
TraceBlockByHash(ctx context.Context, hash common.Hash, config *tracers.TraceConfig, stream *jsoniter.Stream) error
TraceBlockByNumber(ctx context.Context, number rpc.BlockNumber, config *tracers.TraceConfig, stream *jsoniter.Stream) error
AccountRange(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash, start []byte, maxResults int, nocode, nostorage bool) (state.IteratorDump, error)
GetModifiedAccountsByNumber(ctx context.Context, startNum rpc.BlockNumber, endNum *rpc.BlockNumber) ([]libcommon.Address, error)
GetModifiedAccountsByHash(_ context.Context, startHash libcommon.Hash, endHash *libcommon.Hash) ([]libcommon.Address, error)
GetModifiedAccountsByNumber(ctx context.Context, startNum rpc.BlockNumber, endNum *rpc.BlockNumber) ([]common.Address, error)
GetModifiedAccountsByHash(_ context.Context, startHash common.Hash, endHash *common.Hash) ([]common.Address, error)
TraceCall(ctx context.Context, args ethapi.CallArgs, blockNrOrHash rpc.BlockNumberOrHash, config *tracers.TraceConfig, stream *jsoniter.Stream) error
AccountAt(ctx context.Context, blockHash libcommon.Hash, txIndex uint64, account libcommon.Address) (*AccountResult, error)
AccountAt(ctx context.Context, blockHash common.Hash, txIndex uint64, account common.Address) (*AccountResult, error)
}
// PrivateDebugAPIImpl is implementation of the PrivateDebugAPI interface based on remote Db access
@ -53,7 +53,7 @@ func NewPrivateDebugAPI(base *BaseAPI, db kv.RoDB, gascap uint64) *PrivateDebugA
}
// storageRangeAt implements debug_storageRangeAt. Returns information about a range of storage locations (if any) for the given address.
func (api *PrivateDebugAPIImpl) StorageRangeAt(ctx context.Context, blockHash libcommon.Hash, txIndex uint64, contractAddress libcommon.Address, keyStart hexutil.Bytes, maxResult int) (StorageRangeResult, error) {
func (api *PrivateDebugAPIImpl) StorageRangeAt(ctx context.Context, blockHash common.Hash, txIndex uint64, contractAddress common.Address, keyStart hexutil.Bytes, maxResult int) (StorageRangeResult, error) {
tx, err := api.db.BeginRo(ctx)
if err != nil {
return StorageRangeResult{}, err
@ -131,7 +131,7 @@ func (api *PrivateDebugAPIImpl) AccountRange(ctx context.Context, blockNrOrHash
}
dumper := state.NewDumper(tx, blockNumber)
res, err := dumper.IteratorDump(excludeCode, excludeStorage, libcommon.BytesToAddress(startKey), maxResults)
res, err := dumper.IteratorDump(excludeCode, excludeStorage, common.BytesToAddress(startKey), maxResults)
if err != nil {
return state.IteratorDump{}, err
}
@ -140,7 +140,7 @@ func (api *PrivateDebugAPIImpl) AccountRange(ctx context.Context, blockNrOrHash
if err != nil {
return state.IteratorDump{}, err
}
if hash != (libcommon.Hash{}) {
if hash != (common.Hash{}) {
header := rawdb.ReadHeader(tx, hash, blockNumber)
if header != nil {
res.Root = header.Root.String()
@ -151,7 +151,7 @@ func (api *PrivateDebugAPIImpl) AccountRange(ctx context.Context, blockNrOrHash
}
// GetModifiedAccountsByNumber implements debug_getModifiedAccountsByNumber. Returns a list of accounts modified in the given block.
func (api *PrivateDebugAPIImpl) GetModifiedAccountsByNumber(ctx context.Context, startNumber rpc.BlockNumber, endNumber *rpc.BlockNumber) ([]libcommon.Address, error) {
func (api *PrivateDebugAPIImpl) GetModifiedAccountsByNumber(ctx context.Context, startNumber rpc.BlockNumber, endNumber *rpc.BlockNumber) ([]common.Address, error) {
tx, err := api.db.BeginRo(ctx)
if err != nil {
return nil, err
@ -188,7 +188,7 @@ func (api *PrivateDebugAPIImpl) GetModifiedAccountsByNumber(ctx context.Context,
}
// GetModifiedAccountsByHash implements debug_getModifiedAccountsByHash. Returns a list of accounts modified in the given block.
func (api *PrivateDebugAPIImpl) GetModifiedAccountsByHash(ctx context.Context, startHash libcommon.Hash, endHash *libcommon.Hash) ([]libcommon.Address, error) {
func (api *PrivateDebugAPIImpl) GetModifiedAccountsByHash(ctx context.Context, startHash common.Hash, endHash *common.Hash) ([]common.Address, error) {
tx, err := api.db.BeginRo(ctx)
if err != nil {
return nil, err
@ -223,7 +223,7 @@ func (api *PrivateDebugAPIImpl) GetModifiedAccountsByHash(ctx context.Context, s
return changeset.GetModifiedAccounts(tx, startNum, endNum)
}
func (api *PrivateDebugAPIImpl) AccountAt(ctx context.Context, blockHash libcommon.Hash, txIndex uint64, address libcommon.Address) (*AccountResult, error) {
func (api *PrivateDebugAPIImpl) AccountAt(ctx context.Context, blockHash common.Hash, txIndex uint64, address common.Address) (*AccountResult, error) {
tx, err := api.db.BeginRo(ctx)
if err != nil {
return nil, err
@ -259,5 +259,5 @@ type AccountResult struct {
Balance hexutil.Big `json:"balance"`
Nonce hexutil.Uint64 `json:"nonce"`
Code hexutil.Bytes `json:"code"`
CodeHash libcommon.Hash `json:"codeHash"`
CodeHash common.Hash `json:"codeHash"`
}

52
cmd/rpcdaemon/commands/debug_api_test.go
View File

@ -8,7 +8,7 @@ import (
"github.com/davecgh/go-spew/spew"
jsoniter "github.com/json-iterator/go"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/kv"
"github.com/ledgerwatch/erigon-lib/kv/iter"
"github.com/ledgerwatch/erigon-lib/kv/kvcache"
@ -60,7 +60,7 @@ func TestTraceBlockByNumber(t *testing.T) {
for _, tt := range debugTraceTransactionTests {
var buf bytes.Buffer
stream := jsoniter.NewStream(jsoniter.ConfigDefault, &buf, 4096)
tx, err := ethApi.GetTransactionByHash(m.Ctx, libcommon.HexToHash(tt.txHash))
tx, err := ethApi.GetTransactionByHash(m.Ctx, common.HexToHash(tt.txHash))
if err != nil {
t.Errorf("traceBlock %s: %v", tt.txHash, err)
}
@ -109,7 +109,7 @@ func TestTraceBlockByHash(t *testing.T) {
for _, tt := range debugTraceTransactionTests {
var buf bytes.Buffer
stream := jsoniter.NewStream(jsoniter.ConfigDefault, &buf, 4096)
tx, err := ethApi.GetTransactionByHash(m.Ctx, libcommon.HexToHash(tt.txHash))
tx, err := ethApi.GetTransactionByHash(m.Ctx, common.HexToHash(tt.txHash))
if err != nil {
t.Errorf("traceBlock %s: %v", tt.txHash, err)
}
@ -144,7 +144,7 @@ func TestTraceTransaction(t *testing.T) {
for _, tt := range debugTraceTransactionTests {
var buf bytes.Buffer
stream := jsoniter.NewStream(jsoniter.ConfigDefault, &buf, 4096)
err := api.TraceTransaction(m.Ctx, libcommon.HexToHash(tt.txHash), &tracers.TraceConfig{}, stream)
err := api.TraceTransaction(m.Ctx, common.HexToHash(tt.txHash), &tracers.TraceConfig{}, stream)
if err != nil {
t.Errorf("traceTransaction %s: %v", tt.txHash, err)
}
@ -178,7 +178,7 @@ func TestTraceTransactionNoRefund(t *testing.T) {
var buf bytes.Buffer
stream := jsoniter.NewStream(jsoniter.ConfigDefault, &buf, 4096)
var norefunds = true
err := api.TraceTransaction(m.Ctx, libcommon.HexToHash(tt.txHash), &tracers.TraceConfig{NoRefunds: &norefunds}, stream)
err := api.TraceTransaction(m.Ctx, common.HexToHash(tt.txHash), &tracers.TraceConfig{NoRefunds: &norefunds}, stream)
if err != nil {
t.Errorf("traceTransaction %s: %v", tt.txHash, err)
}
@ -215,7 +215,7 @@ func TestStorageRangeAt(t *testing.T) {
return nil
})
require.NoError(t, err)
addr := libcommon.HexToAddress("0x537e697c7ab75a26f9ecf0ce810e3154dfcaaf55")
addr := common.HexToAddress("0x537e697c7ab75a26f9ecf0ce810e3154dfcaaf55")
expect := StorageRangeResult{storageMap{}, nil}
result, err := api.StorageRangeAt(m.Ctx, block4.Hash(), 0, addr, nil, 100)
require.NoError(t, err)
@ -228,13 +228,13 @@ func TestStorageRangeAt(t *testing.T) {
return nil
})
require.NoError(t, err)
addr := libcommon.HexToAddress("0x537e697c7ab75a26f9ecf0ce810e3154dfcaaf44")
keys := []libcommon.Hash{ // hashes of Keys of storage
libcommon.HexToHash("0x405787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5ace"),
libcommon.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000002"),
addr := common.HexToAddress("0x537e697c7ab75a26f9ecf0ce810e3154dfcaaf44")
keys := []common.Hash{ // hashes of Keys of storage
common.HexToHash("0x405787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5ace"),
common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000002"),
}
storage := storageMap{
keys[0]: {Key: &keys[1], Value: libcommon.HexToHash("0000000000000000000000000d3ab14bbad3d99f4203bd7a11acb94882050e7e")},
keys[0]: {Key: &keys[1], Value: common.HexToHash("0000000000000000000000000d3ab14bbad3d99f4203bd7a11acb94882050e7e")},
}
expect := StorageRangeResult{storageMap{keys[0]: storage[keys[0]]}, nil}
@ -249,25 +249,25 @@ func TestStorageRangeAt(t *testing.T) {
return nil
})
require.NoError(t, err)
addr := libcommon.HexToAddress("0x537e697c7ab75a26f9ecf0ce810e3154dfcaaf44")
keys := []libcommon.Hash{ // hashes of Keys of storage
libcommon.HexToHash("0x290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563"),
libcommon.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"),
addr := common.HexToAddress("0x537e697c7ab75a26f9ecf0ce810e3154dfcaaf44")
keys := []common.Hash{ // hashes of Keys of storage
common.HexToHash("0x290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563"),
common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"),
libcommon.HexToHash("0x405787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5ace"),
libcommon.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000002"),
common.HexToHash("0x405787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5ace"),
common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000002"),
libcommon.HexToHash("0xb077f7530a1364c54ee00cf94ba99175db81e7e002c97e344aa5d3c4908617c4"),
libcommon.HexToHash("0x9541d803110b392ecde8e03af7ae34d4457eb4934dac09903ccee819bec4a355"),
common.HexToHash("0xb077f7530a1364c54ee00cf94ba99175db81e7e002c97e344aa5d3c4908617c4"),
common.HexToHash("0x9541d803110b392ecde8e03af7ae34d4457eb4934dac09903ccee819bec4a355"),
libcommon.HexToHash("0xb6b80924ee71b506e16a000e00b0f8f3a82f53791c6b87f5958fdf562f3d12c8"),
libcommon.HexToHash("0xf41f8421ae8c8d7bb78783a0bdadb801a5f895bea868c1d867ae007558809ef1"),
common.HexToHash("0xb6b80924ee71b506e16a000e00b0f8f3a82f53791c6b87f5958fdf562f3d12c8"),
common.HexToHash("0xf41f8421ae8c8d7bb78783a0bdadb801a5f895bea868c1d867ae007558809ef1"),
}
storage := storageMap{
keys[0]: {Key: &keys[1], Value: libcommon.HexToHash("0x000000000000000000000000000000000000000000000000000000000000000a")},
keys[2]: {Key: &keys[3], Value: libcommon.HexToHash("0x0000000000000000000000000d3ab14bbad3d99f4203bd7a11acb94882050e7e")},
keys[4]: {Key: &keys[5], Value: libcommon.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000003")},
keys[6]: {Key: &keys[7], Value: libcommon.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000007")},
keys[0]: {Key: &keys[1], Value: common.HexToHash("0x000000000000000000000000000000000000000000000000000000000000000a")},
keys[2]: {Key: &keys[3], Value: common.HexToHash("0x0000000000000000000000000d3ab14bbad3d99f4203bd7a11acb94882050e7e")},
keys[4]: {Key: &keys[5], Value: common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000003")},
keys[6]: {Key: &keys[7], Value: common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000007")},
}
expect := StorageRangeResult{
storageMap{keys[0]: storage[keys[0]], keys[2]: storage[keys[2]], keys[4]: storage[keys[4]], keys[6]: storage[keys[6]]},
@ -304,7 +304,7 @@ func TestMapTxNum2BlockNum(t *testing.T) {
t.Skip()
}
addr := libcommon.HexToAddress("0x537e697c7ab75a26f9ecf0ce810e3154dfcaaf44")
addr := common.HexToAddress("0x537e697c7ab75a26f9ecf0ce810e3154dfcaaf44")
checkIter := func(t *testing.T, expectTxNums iter.U64, txNumsIter *MapTxNum2BlockNumIter) {
for expectTxNums.HasNext() {
require.True(t, txNumsIter.HasNext())

43
cmd/rpcdaemon/commands/engine_api.go
View File

@ -9,13 +9,12 @@ import (
"github.com/holiman/uint256"
"github.com/ledgerwatch/log/v3"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/gointerfaces"
"github.com/ledgerwatch/erigon-lib/gointerfaces/remote"
types2 "github.com/ledgerwatch/erigon-lib/gointerfaces/types"
"github.com/ledgerwatch/erigon-lib/kv"
"github.com/ledgerwatch/erigon/common"
"github.com/ledgerwatch/erigon/common/hexutil"
"github.com/ledgerwatch/erigon/core/rawdb"
"github.com/ledgerwatch/erigon/core/types"
@ -25,19 +24,19 @@ import (
// ExecutionPayload represents an execution payload (aka block)
type ExecutionPayload struct {
ParentHash libcommon.Hash `json:"parentHash" gencodec:"required"`
FeeRecipient libcommon.Address `json:"feeRecipient" gencodec:"required"`
StateRoot libcommon.Hash `json:"stateRoot" gencodec:"required"`
ReceiptsRoot libcommon.Hash `json:"receiptsRoot" gencodec:"required"`
ParentHash common.Hash `json:"parentHash" gencodec:"required"`
FeeRecipient common.Address `json:"feeRecipient" gencodec:"required"`
StateRoot common.Hash `json:"stateRoot" gencodec:"required"`
ReceiptsRoot common.Hash `json:"receiptsRoot" gencodec:"required"`
LogsBloom hexutil.Bytes `json:"logsBloom" gencodec:"required"`
PrevRandao libcommon.Hash `json:"prevRandao" gencodec:"required"`
PrevRandao common.Hash `json:"prevRandao" gencodec:"required"`
BlockNumber hexutil.Uint64 `json:"blockNumber" gencodec:"required"`
GasLimit hexutil.Uint64 `json:"gasLimit" gencodec:"required"`
GasUsed hexutil.Uint64 `json:"gasUsed" gencodec:"required"`
Timestamp hexutil.Uint64 `json:"timestamp" gencodec:"required"`
ExtraData hexutil.Bytes `json:"extraData" gencodec:"required"`
BaseFeePerGas *hexutil.Big `json:"baseFeePerGas" gencodec:"required"`
BlockHash libcommon.Hash `json:"blockHash" gencodec:"required"`
BlockHash common.Hash `json:"blockHash" gencodec:"required"`
Transactions []hexutil.Bytes `json:"transactions" gencodec:"required"`
Withdrawals []*types.Withdrawal `json:"withdrawals"`
}
@ -50,24 +49,24 @@ type GetPayloadV2Response struct {
// PayloadAttributes represent the attributes required to start assembling a payload
type ForkChoiceState struct {
HeadHash libcommon.Hash `json:"headBlockHash" gencodec:"required"`
SafeBlockHash libcommon.Hash `json:"safeBlockHash" gencodec:"required"`
FinalizedBlockHash libcommon.Hash `json:"finalizedBlockHash" gencodec:"required"`
HeadHash common.Hash `json:"headBlockHash" gencodec:"required"`
SafeBlockHash common.Hash `json:"safeBlockHash" gencodec:"required"`
FinalizedBlockHash common.Hash `json:"finalizedBlockHash" gencodec:"required"`
}
// PayloadAttributes represent the attributes required to start assembling a payload
type PayloadAttributes struct {
Timestamp hexutil.Uint64 `json:"timestamp" gencodec:"required"`
PrevRandao libcommon.Hash `json:"prevRandao" gencodec:"required"`
SuggestedFeeRecipient libcommon.Address `json:"suggestedFeeRecipient" gencodec:"required"`
PrevRandao common.Hash `json:"prevRandao" gencodec:"required"`
SuggestedFeeRecipient common.Address `json:"suggestedFeeRecipient" gencodec:"required"`
Withdrawals []*types.Withdrawal `json:"withdrawals"`
}
// TransitionConfiguration represents the correct configurations of the CL and the EL
type TransitionConfiguration struct {
TerminalTotalDifficulty *hexutil.Big `json:"terminalTotalDifficulty" gencodec:"required"`
TerminalBlockHash libcommon.Hash `json:"terminalBlockHash" gencodec:"required"`
TerminalBlockNumber *hexutil.Big `json:"terminalBlockNumber" gencodec:"required"`
TerminalTotalDifficulty *hexutil.Big `json:"terminalTotalDifficulty" gencodec:"required"`
TerminalBlockHash common.Hash `json:"terminalBlockHash" gencodec:"required"`
TerminalBlockNumber *hexutil.Big `json:"terminalBlockNumber" gencodec:"required"`
}
type ExecutionPayloadBodyV1 struct {
@ -84,7 +83,7 @@ type EngineAPI interface {
GetPayloadV1(ctx context.Context, payloadID hexutil.Bytes) (*ExecutionPayload, error)
GetPayloadV2(ctx context.Context, payloadID hexutil.Bytes) (*GetPayloadV2Response, error)
ExchangeTransitionConfigurationV1(ctx context.Context, transitionConfiguration *TransitionConfiguration) (*TransitionConfiguration, error)
GetPayloadBodiesByHashV1(ctx context.Context, hashes []libcommon.Hash) ([]*ExecutionPayloadBodyV1, error)
GetPayloadBodiesByHashV1(ctx context.Context, hashes []common.Hash) ([]*ExecutionPayloadBodyV1, error)
GetPayloadBodiesByRangeV1(ctx context.Context, start uint64, count uint64) ([]*ExecutionPayloadBodyV1, error)
}
@ -107,8 +106,8 @@ func convertPayloadStatus(ctx context.Context, db kv.RoDB, x *remote.EnginePaylo
return json, nil
}
latestValidHash := libcommon.Hash(gointerfaces.ConvertH256ToHash(x.LatestValidHash))
if latestValidHash == (libcommon.Hash{}) || x.Status == remote.EngineStatus_VALID {
latestValidHash := common.Hash(gointerfaces.ConvertH256ToHash(x.LatestValidHash))
if latestValidHash == (common.Hash{}) || x.Status == remote.EngineStatus_VALID {
json["latestValidHash"] = latestValidHash
return json, nil
}
@ -129,7 +128,7 @@ func convertPayloadStatus(ctx context.Context, db kv.RoDB, x *remote.EnginePaylo
if isValidHashPos {
json["latestValidHash"] = latestValidHash
} else {
json["latestValidHash"] = libcommon.Hash{}
json["latestValidHash"] = common.Hash{}
}
return json, nil
}
@ -361,12 +360,12 @@ func (e *EngineImpl) ExchangeTransitionConfigurationV1(ctx context.Context, beac
return &TransitionConfiguration{
TerminalTotalDifficulty: (*hexutil.Big)(terminalTotalDifficulty),
TerminalBlockHash: libcommon.Hash{},
TerminalBlockHash: common.Hash{},
TerminalBlockNumber: (*hexutil.Big)(common.Big0),
}, nil
}
func (e *EngineImpl) GetPayloadBodiesByHashV1(ctx context.Context, hashes []libcommon.Hash) ([]*ExecutionPayloadBodyV1, error) {
func (e *EngineImpl) GetPayloadBodiesByHashV1(ctx context.Context, hashes []common.Hash) ([]*ExecutionPayloadBodyV1, error) {
h := make([]*types2.H256, len(hashes))
for i, hash := range hashes {
h[i] = gointerfaces.ConvertHashToH256(hash)

6
cmd/rpcdaemon/commands/engine_api_test.go
View File

@ -4,7 +4,7 @@ import (
"context"
"testing"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/gointerfaces"
"github.com/ledgerwatch/erigon-lib/gointerfaces/remote"
"github.com/stretchr/testify/assert"
@ -13,9 +13,9 @@ import (
// Test case for https://github.com/ethereum/execution-apis/pull/217 responses
func TestZeroLatestValidHash(t *testing.T) {
payloadStatus := remote.EnginePayloadStatus{Status: remote.EngineStatus_INVALID, LatestValidHash: gointerfaces.ConvertHashToH256(libcommon.Hash{})}
payloadStatus := remote.EnginePayloadStatus{Status: remote.EngineStatus_INVALID, LatestValidHash: gointerfaces.ConvertHashToH256(common.Hash{})}
json, err := convertPayloadStatus(context.TODO(), nil, &payloadStatus)
require.NoError(t, err)
assert.Equal(t, "INVALID", json["status"])
assert.Equal(t, libcommon.Hash{}, json["latestValidHash"])
assert.Equal(t, common.Hash{}, json["latestValidHash"])
}

10
cmd/rpcdaemon/commands/erigon_api.go
View File

@ -3,7 +3,7 @@ package commands
import (
"context"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon/eth/filters"
ethFilters "github.com/ledgerwatch/erigon/eth/filters"
@ -25,17 +25,17 @@ type ErigonAPI interface {
// Blocks related (see ./erigon_blocks.go)
GetHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Header, error)
GetHeaderByHash(_ context.Context, hash libcommon.Hash) (*types.Header, error)
GetHeaderByHash(_ context.Context, hash common.Hash) (*types.Header, error)
GetBlockByTimestamp(ctx context.Context, timeStamp rpc.Timestamp, fullTx bool) (map[string]interface{}, error)
GetBalanceChangesInBlock(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (map[libcommon.Address]*hexutil.Big, error)
GetBalanceChangesInBlock(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (map[common.Address]*hexutil.Big, error)
// Receipt related (see ./erigon_receipts.go)
GetLogsByHash(ctx context.Context, hash libcommon.Hash) ([][]*types.Log, error)
GetLogsByHash(ctx context.Context, hash common.Hash) ([][]*types.Log, error)
//GetLogsByNumber(ctx context.Context, number rpc.BlockNumber) ([][]*types.Log, error)
GetLogs(ctx context.Context, crit ethFilters.FilterCriteria) (types.ErigonLogs, error)
GetLatestLogs(ctx context.Context, crit filters.FilterCriteria, logOptions ethFilters.LogFilterOptions) (types.ErigonLogs, error)
// Gets cannonical block receipt through hash. If the block is not cannonical returns error
GetBlockReceiptsByBlockHash(ctx context.Context, cannonicalBlockHash libcommon.Hash) ([]map[string]interface{}, error)
GetBlockReceiptsByBlockHash(ctx context.Context, cannonicalBlockHash common.Hash) ([]map[string]interface{}, error)
// CumulativeChainTraffic / related to chain traffic (see ./erigon_cumulative_index.go)
CumulativeChainTraffic(ctx context.Context, blockNr rpc.BlockNumber) (ChainTraffic, error)

12
cmd/rpcdaemon/commands/erigon_block.go
View File

@ -8,7 +8,7 @@ import (
"sort"
"github.com/holiman/uint256"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common/hexutility"
"github.com/ledgerwatch/erigon-lib/kv"
"github.com/ledgerwatch/erigon-lib/kv/temporal/historyv2"
@ -57,7 +57,7 @@ func (api *ErigonImpl) GetHeaderByNumber(ctx context.Context, blockNumber rpc.Bl
}
// GetHeaderByHash implements erigon_getHeaderByHash. Returns a block's header given a block's hash.
func (api *ErigonImpl) GetHeaderByHash(ctx context.Context, hash libcommon.Hash) (*types.Header, error) {
func (api *ErigonImpl) GetHeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error) {
tx, err := api.db.BeginRo(ctx)
if err != nil {
return nil, err
@ -180,7 +180,7 @@ func buildBlockResponse(db kv.Tx, blockNum uint64, fullTx bool) (map[string]inte
additionalFields["totalDifficulty"] = (*hexutil.Big)(td)
}
response, err := ethapi.RPCMarshalBlockEx(block, true, fullTx, nil, libcommon.Hash{}, additionalFields)
response, err := ethapi.RPCMarshalBlockEx(block, true, fullTx, nil, common.Hash{}, additionalFields)
if err == nil && rpc.BlockNumber(block.NumberU64()) == rpc.PendingBlockNumber {
// Pending blocks need to nil out a few fields
@ -191,7 +191,7 @@ func buildBlockResponse(db kv.Tx, blockNum uint64, fullTx bool) (map[string]inte
return response, err
}
func (api *ErigonImpl) GetBalanceChangesInBlock(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (map[libcommon.Address]*hexutil.Big, error) {
func (api *ErigonImpl) GetBalanceChangesInBlock(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (map[common.Address]*hexutil.Big, error) {
tx, err := api.db.BeginRo(ctx)
if err != nil {
return nil, err
@ -213,7 +213,7 @@ func (api *ErigonImpl) GetBalanceChangesInBlock(ctx context.Context, blockNrOrHa
decodeFn := historyv2.Mapper[kv.AccountChangeSet].Decode
balancesMapping := make(map[libcommon.Address]*hexutil.Big)
balancesMapping := make(map[common.Address]*hexutil.Big)
newReader, err := rpchelper.CreateStateReader(ctx, tx, blockNrOrHash, 0, api.filters, api.stateCache, api.historyV3(tx), "")
if err != nil {
@ -235,7 +235,7 @@ func (api *ErigonImpl) GetBalanceChangesInBlock(ctx context.Context, blockNrOrHa
}
oldBalance := oldAcc.Balance
address := libcommon.BytesToAddress(addressBytes)
address := common.BytesToAddress(addressBytes)
newAcc, err := newReader.ReadAccountData(address)
if err != nil {

12
cmd/rpcdaemon/commands/erigon_receipts.go
View File

@ -7,7 +7,7 @@ import (
"fmt"
"github.com/RoaringBitmap/roaring"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common/hexutility"
"github.com/ledgerwatch/erigon-lib/kv"
"github.com/ledgerwatch/erigon-lib/kv/bitmapdb"
@ -21,7 +21,7 @@ import (
)
// GetLogsByHash implements erigon_getLogsByHash. Returns an array of arrays of logs generated by the transactions in the block given by the block's hash.
func (api *ErigonImpl) GetLogsByHash(ctx context.Context, hash libcommon.Hash) ([][]*types.Log, error) {
func (api *ErigonImpl) GetLogsByHash(ctx context.Context, hash common.Hash) ([][]*types.Log, error) {
tx, err := api.db.BeginRo(ctx)
if err != nil {
return nil, err
@ -109,7 +109,7 @@ func (api *ErigonImpl) GetLogs(ctx context.Context, crit filters.FilterCriteria)
return erigonLogs, nil
}
addrMap := make(map[libcommon.Address]struct{}, len(crit.Addresses))
addrMap := make(map[common.Address]struct{}, len(crit.Addresses))
for _, v := range crit.Addresses {
addrMap[v] = struct{}{}
}
@ -244,11 +244,11 @@ func (api *ErigonImpl) GetLatestLogs(ctx context.Context, crit filters.FilterCri
return erigonLogs, nil
}
addrMap := make(map[libcommon.Address]struct{}, len(crit.Addresses))
addrMap := make(map[common.Address]struct{}, len(crit.Addresses))
for _, v := range crit.Addresses {
addrMap[v] = struct{}{}
}
topicsMap := make(map[libcommon.Hash]struct{})
topicsMap := make(map[common.Hash]struct{})
for i := range crit.Topics {
for j := range crit.Topics {
topicsMap[crit.Topics[i][j]] = struct{}{}
@ -356,7 +356,7 @@ func (api *ErigonImpl) GetLatestLogs(ctx context.Context, crit filters.FilterCri
return erigonLogs, nil
}
func (api *ErigonImpl) GetBlockReceiptsByBlockHash(ctx context.Context, cannonicalBlockHash libcommon.Hash) ([]map[string]interface{}, error) {
func (api *ErigonImpl) GetBlockReceiptsByBlockHash(ctx context.Context, cannonicalBlockHash common.Hash) ([]map[string]interface{}, error) {
tx, err := api.db.BeginRo(ctx)
if err != nil {
return nil, err

8
cmd/rpcdaemon/commands/erigon_system.go
View File

@ -3,7 +3,7 @@ package commands
import (
"context"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon/common/hexutil"
"github.com/ledgerwatch/erigon/core/forkid"
@ -13,9 +13,9 @@ import (
// Forks is a data type to record a list of forks passed by this node
type Forks struct {
GenesisHash libcommon.Hash `json:"genesis"`
HeightForks []uint64 `json:"heightForks"`
TimeForks []uint64 `json:"timeForks"`
GenesisHash common.Hash `json:"genesis"`
HeightForks []uint64 `json:"heightForks"`
TimeForks []uint64 `json:"timeForks"`
}
// Forks implements erigon_forks. Returns the genesis block hash and a sorted list of all forks block numbers

82
cmd/rpcdaemon/commands/eth_api.go
View File

@ -9,7 +9,7 @@ import (
lru "github.com/hashicorp/golang-lru"
"github.com/holiman/uint256"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common"
types2 "github.com/ledgerwatch/erigon-lib/types"
"github.com/ledgerwatch/log/v3"
@ -39,26 +39,26 @@ type EthAPI interface {
GetBlockByNumber(ctx context.Context, number rpc.BlockNumber, fullTx bool) (map[string]interface{}, error)
GetBlockByHash(ctx context.Context, hash rpc.BlockNumberOrHash, fullTx bool) (map[string]interface{}, error)
GetBlockTransactionCountByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*hexutil.Uint, error)
GetBlockTransactionCountByHash(ctx context.Context, blockHash libcommon.Hash) (*hexutil.Uint, error)
GetBlockTransactionCountByHash(ctx context.Context, blockHash common.Hash) (*hexutil.Uint, error)
// Transaction related (see ./eth_txs.go)
GetTransactionByHash(ctx context.Context, hash libcommon.Hash) (*RPCTransaction, error)
GetTransactionByBlockHashAndIndex(ctx context.Context, blockHash libcommon.Hash, txIndex hexutil.Uint64) (*RPCTransaction, error)
GetTransactionByHash(ctx context.Context, hash common.Hash) (*RPCTransaction, error)
GetTransactionByBlockHashAndIndex(ctx context.Context, blockHash common.Hash, txIndex hexutil.Uint64) (*RPCTransaction, error)
GetTransactionByBlockNumberAndIndex(ctx context.Context, blockNr rpc.BlockNumber, txIndex hexutil.Uint) (*RPCTransaction, error)
GetRawTransactionByBlockNumberAndIndex(ctx context.Context, blockNr rpc.BlockNumber, index hexutil.Uint) (hexutil.Bytes, error)
GetRawTransactionByBlockHashAndIndex(ctx context.Context, blockHash libcommon.Hash, index hexutil.Uint) (hexutil.Bytes, error)
GetRawTransactionByHash(ctx context.Context, hash libcommon.Hash) (hexutil.Bytes, error)
GetRawTransactionByBlockHashAndIndex(ctx context.Context, blockHash common.Hash, index hexutil.Uint) (hexutil.Bytes, error)
GetRawTransactionByHash(ctx context.Context, hash common.Hash) (hexutil.Bytes, error)
// Receipt related (see ./eth_receipts.go)
GetTransactionReceipt(ctx context.Context, hash libcommon.Hash) (map[string]interface{}, error)
GetTransactionReceipt(ctx context.Context, hash common.Hash) (map[string]interface{}, error)
GetLogs(ctx context.Context, crit ethFilters.FilterCriteria) (types.Logs, error)
GetBlockReceipts(ctx context.Context, number rpc.BlockNumber) ([]map[string]interface{}, error)
// Uncle related (see ./eth_uncles.go)
GetUncleByBlockNumberAndIndex(ctx context.Context, blockNr rpc.BlockNumber, index hexutil.Uint) (map[string]interface{}, error)
GetUncleByBlockHashAndIndex(ctx context.Context, hash libcommon.Hash, index hexutil.Uint) (map[string]interface{}, error)
GetUncleByBlockHashAndIndex(ctx context.Context, hash common.Hash, index hexutil.Uint) (map[string]interface{}, error)
GetUncleCountByBlockNumber(ctx context.Context, number rpc.BlockNumber) (*hexutil.Uint, error)
GetUncleCountByBlockHash(ctx context.Context, hash libcommon.Hash) (*hexutil.Uint, error)
GetUncleCountByBlockHash(ctx context.Context, hash common.Hash) (*hexutil.Uint, error)
// Filter related (see ./eth_filters.go)
NewPendingTransactionFilter(_ context.Context) (string, error)
@ -68,11 +68,11 @@ type EthAPI interface {
GetFilterChanges(_ context.Context, index string) ([]interface{}, error)
// Account related (see ./eth_accounts.go)
Accounts(ctx context.Context) ([]libcommon.Address, error)
GetBalance(ctx context.Context, address libcommon.Address, blockNrOrHash rpc.BlockNumberOrHash) (*hexutil.Big, error)
GetTransactionCount(ctx context.Context, address libcommon.Address, blockNrOrHash rpc.BlockNumberOrHash) (*hexutil.Uint64, error)
GetStorageAt(ctx context.Context, address libcommon.Address, index string, blockNrOrHash rpc.BlockNumberOrHash) (string, error)
GetCode(ctx context.Context, address libcommon.Address, blockNrOrHash rpc.BlockNumberOrHash) (hexutil.Bytes, error)
Accounts(ctx context.Context) ([]common.Address, error)
GetBalance(ctx context.Context, address common.Address, blockNrOrHash rpc.BlockNumberOrHash) (*hexutil.Big, error)
GetTransactionCount(ctx context.Context, address common.Address, blockNrOrHash rpc.BlockNumberOrHash) (*hexutil.Uint64, error)
GetStorageAt(ctx context.Context, address common.Address, index string, blockNrOrHash rpc.BlockNumberOrHash) (string, error)
GetCode(ctx context.Context, address common.Address, blockNrOrHash rpc.BlockNumberOrHash) (hexutil.Bytes, error)
// System related (see ./eth_system.go)
BlockNumber(ctx context.Context) (hexutil.Uint64, error)
@ -84,20 +84,20 @@ type EthAPI interface {
// Sending related (see ./eth_call.go)
Call(ctx context.Context, args ethapi2.CallArgs, blockNrOrHash rpc.BlockNumberOrHash, overrides *ethapi2.StateOverrides) (hexutil.Bytes, error)
EstimateGas(ctx context.Context, argsOrNil *ethapi2.CallArgs, blockNrOrHash *rpc.BlockNumberOrHash) (hexutil.Uint64, error)
SendRawTransaction(ctx context.Context, encodedTx hexutil.Bytes) (libcommon.Hash, error)
SendTransaction(_ context.Context, txObject interface{}) (libcommon.Hash, error)
Sign(ctx context.Context, _ libcommon.Address, _ hexutil.Bytes) (hexutil.Bytes, error)
SignTransaction(_ context.Context, txObject interface{}) (libcommon.Hash, error)
GetProof(ctx context.Context, address libcommon.Address, storageKeys []string, blockNr rpc.BlockNumber) (*interface{}, error)
SendRawTransaction(ctx context.Context, encodedTx hexutil.Bytes) (common.Hash, error)
SendTransaction(_ context.Context, txObject interface{}) (common.Hash, error)
Sign(ctx context.Context, _ common.Address, _ hexutil.Bytes) (hexutil.Bytes, error)
SignTransaction(_ context.Context, txObject interface{}) (common.Hash, error)
GetProof(ctx context.Context, address common.Address, storageKeys []string, blockNr rpc.BlockNumber) (*interface{}, error)
CreateAccessList(ctx context.Context, args ethapi2.CallArgs, blockNrOrHash *rpc.BlockNumberOrHash, optimizeGas *bool) (*accessListResult, error)
// Mining related (see ./eth_mining.go)
Coinbase(ctx context.Context) (libcommon.Address, error)
Coinbase(ctx context.Context) (common.Address, error)
Hashrate(ctx context.Context) (uint64, error)
Mining(ctx context.Context) (bool, error)
GetWork(ctx context.Context) ([4]string, error)
SubmitWork(ctx context.Context, nonce types.BlockNonce, powHash, digest libcommon.Hash) (bool, error)
SubmitHashrate(ctx context.Context, hashRate hexutil.Uint64, id libcommon.Hash) (bool, error)
SubmitWork(ctx context.Context, nonce types.BlockNonce, powHash, digest common.Hash) (bool, error)
SubmitHashrate(ctx context.Context, hashRate hexutil.Uint64, id common.Hash) (bool, error)
}
type BaseAPI struct {
@ -147,7 +147,7 @@ func (api *BaseAPI) genesis(tx kv.Tx) (*types.Block, error) {
return genesis, err
}
func (api *BaseAPI) txnLookup(ctx context.Context, tx kv.Tx, txnHash libcommon.Hash) (uint64, bool, error) {
func (api *BaseAPI) txnLookup(ctx context.Context, tx kv.Tx, txnHash common.Hash) (uint64, bool, error) {
return api._txnReader.TxnLookup(ctx, tx, txnHash)
}
@ -159,7 +159,7 @@ func (api *BaseAPI) blockByNumberWithSenders(tx kv.Tx, number uint64) (*types.Bl
return api.blockWithSenders(tx, hash, number)
}
func (api *BaseAPI) blockByHashWithSenders(tx kv.Tx, hash libcommon.Hash) (*types.Block, error) {
func (api *BaseAPI) blockByHashWithSenders(tx kv.Tx, hash common.Hash) (*types.Block, error) {
if api.blocksLRU != nil {
if it, ok := api.blocksLRU.Get(hash); ok && it != nil {
return it.(*types.Block), nil
@ -173,7 +173,7 @@ func (api *BaseAPI) blockByHashWithSenders(tx kv.Tx, hash libcommon.Hash) (*type
return api.blockWithSenders(tx, hash, *number)
}
func (api *BaseAPI) blockWithSenders(tx kv.Tx, hash libcommon.Hash, number uint64) (*types.Block, error) {
func (api *BaseAPI) blockWithSenders(tx kv.Tx, hash common.Hash, number uint64) (*types.Block, error) {
if api.blocksLRU != nil {
if it, ok := api.blocksLRU.Get(hash); ok && it != nil {
return it.(*types.Block), nil
@ -300,17 +300,17 @@ func NewEthAPI(base *BaseAPI, db kv.RoDB, eth rpchelper.ApiBackend, txPool txpoo
// RPCTransaction represents a transaction that will serialize to the RPC representation of a transaction
type RPCTransaction struct {
BlockHash *libcommon.Hash `json:"blockHash"`
BlockHash *common.Hash `json:"blockHash"`
BlockNumber *hexutil.Big `json:"blockNumber"`
From libcommon.Address `json:"from"`
From common.Address `json:"from"`
Gas hexutil.Uint64 `json:"gas"`
GasPrice *hexutil.Big `json:"gasPrice,omitempty"`
Tip *hexutil.Big `json:"maxPriorityFeePerGas,omitempty"`
FeeCap *hexutil.Big `json:"maxFeePerGas,omitempty"`
Hash libcommon.Hash `json:"hash"`
Hash common.Hash `json:"hash"`
Input hexutil.Bytes `json:"input"`
Nonce hexutil.Uint64 `json:"nonce"`
To *libcommon.Address `json:"to"`
To *common.Address `json:"to"`
TransactionIndex *hexutil.Uint64 `json:"transactionIndex"`
Value *hexutil.Big `json:"value"`
Type hexutil.Uint64 `json:"type"`
@ -323,7 +323,7 @@ type RPCTransaction struct {
// newRPCTransaction returns a transaction that will serialize to the RPC
// representation, with the given location metadata set (if available).
func newRPCTransaction(tx types.Transaction, blockHash libcommon.Hash, blockNumber uint64, index uint64, baseFee *big.Int) *RPCTransaction {
func newRPCTransaction(tx types.Transaction, blockHash common.Hash, blockNumber uint64, index uint64, baseFee *big.Int) *RPCTransaction {
// Determine the signer. For replay-protected transactions, use the most permissive
// signer, because we assume that signers are backwards-compatible with old
// transactions. For non-protected transactions, the homestead signer signer is used
@ -367,7 +367,7 @@ func newRPCTransaction(tx types.Transaction, blockHash libcommon.Hash, blockNumb
result.S = (*hexutil.Big)(t.S.ToBig())
result.Accesses = &t.AccessList
baseFee, overflow := uint256.FromBig(baseFee)
if baseFee != nil && !overflow && blockHash != (libcommon.Hash{}) {
if baseFee != nil && !overflow && blockHash != (common.Hash{}) {
// price = min(tip + baseFee, gasFeeCap)
price := math.Min256(new(uint256.Int).Add(tx.GetTip(), baseFee), tx.GetFeeCap())
result.GasPrice = (*hexutil.Big)(price.ToBig())
@ -377,7 +377,7 @@ func newRPCTransaction(tx types.Transaction, blockHash libcommon.Hash, blockNumb
}
signer := types.LatestSignerForChainID(chainId.ToBig())
result.From, _ = tx.Sender(*signer)
if blockHash != (libcommon.Hash{}) {
if blockHash != (common.Hash{}) {
result.BlockHash = &blockHash
result.BlockNumber = (*hexutil.Big)(new(big.Int).SetUint64(blockNumber))
result.TransactionIndex = (*hexutil.Uint64)(&index)
@ -387,7 +387,7 @@ func newRPCTransaction(tx types.Transaction, blockHash libcommon.Hash, blockNumb
// newRPCBorTransaction returns a Bor transaction that will serialize to the RPC
// representation, with the given location metadata set (if available).
func newRPCBorTransaction(opaqueTx types.Transaction, txHash libcommon.Hash, blockHash libcommon.Hash, blockNumber uint64, index uint64, baseFee *big.Int, chainId *big.Int) *RPCTransaction {
func newRPCBorTransaction(opaqueTx types.Transaction, txHash common.Hash, blockHash common.Hash, blockNumber uint64, index uint64, baseFee *big.Int, chainId *big.Int) *RPCTransaction {
tx := opaqueTx.(*types.LegacyTx)
result := &RPCTransaction{
Type: hexutil.Uint64(tx.Type()),
@ -397,14 +397,14 @@ func newRPCBorTransaction(opaqueTx types.Transaction, txHash libcommon.Hash, blo
Hash: txHash,
Input: hexutil.Bytes(tx.GetData()),
Nonce: hexutil.Uint64(tx.GetNonce()),
From: libcommon.Address{},
From: common.Address{},
To: tx.GetTo(),
Value: (*hexutil.Big)(tx.GetValue().ToBig()),
V: (*hexutil.Big)(big.NewInt(0)),
R: (*hexutil.Big)(big.NewInt(0)),
S: (*hexutil.Big)(big.NewInt(0)),
}
if blockHash != (libcommon.Hash{}) {
if blockHash != (common.Hash{}) {
result.ChainID = (*hexutil.Big)(new(big.Int).SetUint64(chainId.Uint64()))
result.BlockHash = &blockHash
result.BlockNumber = (*hexutil.Big)(new(big.Int).SetUint64(blockNumber))
@ -419,7 +419,7 @@ func newRPCPendingTransaction(tx types.Transaction, current *types.Header, confi
if current != nil {
baseFee = misc.CalcBaseFee(config, current)
}
return newRPCTransaction(tx, libcommon.Hash{}, 0, 0, baseFee)
return newRPCTransaction(tx, common.Hash{}, 0, 0, baseFee)
}
// newRPCRawTransactionFromBlockIndex returns the bytes of a transaction given a block and a transaction index.
@ -435,19 +435,19 @@ func newRPCRawTransactionFromBlockIndex(b *types.Block, index uint64) (hexutil.B
type GasPriceCache struct {
latestPrice *big.Int
latestHash libcommon.Hash
latestHash common.Hash
mtx sync.Mutex
}
func NewGasPriceCache() *GasPriceCache {
return &GasPriceCache{
latestPrice: big.NewInt(0),
latestHash: libcommon.Hash{},
latestHash: common.Hash{},
}
}
func (c *GasPriceCache) GetLatest() (libcommon.Hash, *big.Int) {
var hash libcommon.Hash
func (c *GasPriceCache) GetLatest() (common.Hash, *big.Int) {
var hash common.Hash
var price *big.Int
c.mtx.Lock()
hash = c.latestHash
@ -456,7 +456,7 @@ func (c *GasPriceCache) GetLatest() (libcommon.Hash, *big.Int) {
return hash, price
}
func (c *GasPriceCache) SetLatest(hash libcommon.Hash, price *big.Int) {
func (c *GasPriceCache) SetLatest(hash common.Hash, price *big.Int) {
c.mtx.Lock()
c.latestPrice = price
c.latestHash = hash

44
cmd/rpcdaemon/commands/eth_api_test.go
View File

@ -6,7 +6,7 @@ import (
"testing"
"github.com/holiman/uint256"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common"
"github.com/stretchr/testify/assert"
"github.com/ledgerwatch/erigon/common/hexutil"
@ -34,10 +34,10 @@ func TestGetBalanceChangesInBlock(t *testing.T) {
if err != nil {
t.Errorf("calling GetBalanceChangesInBlock resulted in an error: %v", err)
}
expected := map[libcommon.Address]*hexutil.Big{
libcommon.HexToAddress("0x0D3ab14BBaD3D99F4203bd7a11aCB94882050E7e"): (*hexutil.Big)(uint256.NewInt(200000000000000000).ToBig()),
libcommon.HexToAddress("0x703c4b2bD70c169f5717101CaeE543299Fc946C7"): (*hexutil.Big)(uint256.NewInt(300000000000000000).ToBig()),
libcommon.HexToAddress("0x71562b71999873DB5b286dF957af199Ec94617F7"): (*hexutil.Big)(uint256.NewInt(9000000000000000000).ToBig()),
expected := map[common.Address]*hexutil.Big{
common.HexToAddress("0x0D3ab14BBaD3D99F4203bd7a11aCB94882050E7e"): (*hexutil.Big)(uint256.NewInt(200000000000000000).ToBig()),
common.HexToAddress("0x703c4b2bD70c169f5717101CaeE543299Fc946C7"): (*hexutil.Big)(uint256.NewInt(300000000000000000).ToBig()),
common.HexToAddress("0x71562b71999873DB5b286dF957af199Ec94617F7"): (*hexutil.Big)(uint256.NewInt(9000000000000000000).ToBig()),
}
assert.Equal(len(expected), len(balances))
for i := range balances {
@ -54,7 +54,7 @@ func TestGetTransactionReceipt(t *testing.T) {
stateCache := kvcache.New(kvcache.DefaultCoherentConfig)
api := NewEthAPI(NewBaseApi(nil, stateCache, br, agg, false, rpccfg.DefaultEvmCallTimeout, m.Engine), db, nil, nil, nil, 5000000, 100_000)
// Call GetTransactionReceipt for transaction which is not in the database
if _, err := api.GetTransactionReceipt(context.Background(), libcommon.Hash{}); err != nil {
if _, err := api.GetTransactionReceipt(context.Background(), common.Hash{}); err != nil {
t.Errorf("calling GetTransactionReceipt with empty hash: %v", err)
}
}
@ -66,7 +66,7 @@ func TestGetTransactionReceiptUnprotected(t *testing.T) {
stateCache := kvcache.New(kvcache.DefaultCoherentConfig)
api := NewEthAPI(NewBaseApi(nil, stateCache, br, agg, false, rpccfg.DefaultEvmCallTimeout, m.Engine), m.DB, nil, nil, nil, 5000000, 100_000)
// Call GetTransactionReceipt for un-protected transaction
if _, err := api.GetTransactionReceipt(context.Background(), libcommon.HexToHash("0x3f3cb8a0e13ed2481f97f53f7095b9cbc78b6ffb779f2d3e565146371a8830ea")); err != nil {
if _, err := api.GetTransactionReceipt(context.Background(), common.HexToHash("0x3f3cb8a0e13ed2481f97f53f7095b9cbc78b6ffb779f2d3e565146371a8830ea")); err != nil {
t.Errorf("calling GetTransactionReceipt for unprotected tx: %v", err)
}
}
@ -80,14 +80,14 @@ func TestGetStorageAt_ByBlockNumber_WithRequireCanonicalDefault(t *testing.T) {
br := snapshotsync.NewBlockReaderWithSnapshots(m.BlockSnapshots)
stateCache := kvcache.New(kvcache.DefaultCoherentConfig)
api := NewEthAPI(NewBaseApi(nil, stateCache, br, agg, false, rpccfg.DefaultEvmCallTimeout, m.Engine), m.DB, nil, nil, nil, 5000000, 100_000)
addr := libcommon.HexToAddress("0x71562b71999873db5b286df957af199ec94617f7")
addr := common.HexToAddress("0x71562b71999873db5b286df957af199ec94617f7")
result, err := api.GetStorageAt(context.Background(), addr, "0x0", rpc.BlockNumberOrHashWithNumber(0))
if err != nil {
t.Errorf("calling GetStorageAt: %v", err)
}
assert.Equal(libcommon.HexToHash("0x0").String(), result)
assert.Equal(common.HexToHash("0x0").String(), result)
}
func TestGetStorageAt_ByBlockHash_WithRequireCanonicalDefault(t *testing.T) {
@ -97,14 +97,14 @@ func TestGetStorageAt_ByBlockHash_WithRequireCanonicalDefault(t *testing.T) {
br := snapshotsync.NewBlockReaderWithSnapshots(m.BlockSnapshots)
stateCache := kvcache.New(kvcache.DefaultCoherentConfig)
api := NewEthAPI(NewBaseApi(nil, stateCache, br, agg, false, rpccfg.DefaultEvmCallTimeout, m.Engine), m.DB, nil, nil, nil, 5000000, 100_000)
addr := libcommon.HexToAddress("0x71562b71999873db5b286df957af199ec94617f7")
addr := common.HexToAddress("0x71562b71999873db5b286df957af199ec94617f7")
result, err := api.GetStorageAt(context.Background(), addr, "0x0", rpc.BlockNumberOrHashWithHash(m.Genesis.Hash(), false))
if err != nil {
t.Errorf("calling GetStorageAt: %v", err)
}
assert.Equal(libcommon.HexToHash("0x0").String(), result)
assert.Equal(common.HexToHash("0x0").String(), result)
}
func TestGetStorageAt_ByBlockHash_WithRequireCanonicalTrue(t *testing.T) {
@ -114,14 +114,14 @@ func TestGetStorageAt_ByBlockHash_WithRequireCanonicalTrue(t *testing.T) {
br := snapshotsync.NewBlockReaderWithSnapshots(m.BlockSnapshots)
stateCache := kvcache.New(kvcache.DefaultCoherentConfig)
api := NewEthAPI(NewBaseApi(nil, stateCache, br, agg, false, rpccfg.DefaultEvmCallTimeout, m.Engine), m.DB, nil, nil, nil, 5000000, 100_000)
addr := libcommon.HexToAddress("0x71562b71999873db5b286df957af199ec94617f7")
addr := common.HexToAddress("0x71562b71999873db5b286df957af199ec94617f7")
result, err := api.GetStorageAt(context.Background(), addr, "0x0", rpc.BlockNumberOrHashWithHash(m.Genesis.Hash(), true))
if err != nil {
t.Errorf("calling GetStorageAt: %v", err)
}
assert.Equal(libcommon.HexToHash("0x0").String(), result)
assert.Equal(common.HexToHash("0x0").String(), result)
}
func TestGetStorageAt_ByBlockHash_WithRequireCanonicalDefault_BlockNotFoundError(t *testing.T) {
@ -130,7 +130,7 @@ func TestGetStorageAt_ByBlockHash_WithRequireCanonicalDefault_BlockNotFoundError
br := snapshotsync.NewBlockReaderWithSnapshots(m.BlockSnapshots)
stateCache := kvcache.New(kvcache.DefaultCoherentConfig)
api := NewEthAPI(NewBaseApi(nil, stateCache, br, agg, false, rpccfg.DefaultEvmCallTimeout, m.Engine), m.DB, nil, nil, nil, 5000000, 100_000)
addr := libcommon.HexToAddress("0x71562b71999873db5b286df957af199ec94617f7")
addr := common.HexToAddress("0x71562b71999873db5b286df957af199ec94617f7")
offChain, err := core.GenerateChain(m.ChainConfig, m.Genesis, m.Engine, m.DB, 1, func(i int, block *core.BlockGen) {
}, true)
@ -154,7 +154,7 @@ func TestGetStorageAt_ByBlockHash_WithRequireCanonicalTrue_BlockNotFoundError(t
br := snapshotsync.NewBlockReaderWithSnapshots(m.BlockSnapshots)
stateCache := kvcache.New(kvcache.DefaultCoherentConfig)
api := NewEthAPI(NewBaseApi(nil, stateCache, br, agg, false, rpccfg.DefaultEvmCallTimeout, m.Engine), m.DB, nil, nil, nil, 5000000, 100_000)
addr := libcommon.HexToAddress("0x71562b71999873db5b286df957af199ec94617f7")
addr := common.HexToAddress("0x71562b71999873db5b286df957af199ec94617f7")
offChain, err := core.GenerateChain(m.ChainConfig, m.Genesis, m.Engine, m.DB, 1, func(i int, block *core.BlockGen) {
}, true)
@ -179,7 +179,7 @@ func TestGetStorageAt_ByBlockHash_WithRequireCanonicalDefault_NonCanonicalBlock(
br := snapshotsync.NewBlockReaderWithSnapshots(m.BlockSnapshots)
stateCache := kvcache.New(kvcache.DefaultCoherentConfig)
api := NewEthAPI(NewBaseApi(nil, stateCache, br, agg, false, rpccfg.DefaultEvmCallTimeout, m.Engine), m.DB, nil, nil, nil, 5000000, 100_000)
addr := libcommon.HexToAddress("0x71562b71999873db5b286df957af199ec94617f7")
addr := common.HexToAddress("0x71562b71999873db5b286df957af199ec94617f7")
orphanedBlock := orphanedChain[0].Blocks[0]
@ -192,7 +192,7 @@ func TestGetStorageAt_ByBlockHash_WithRequireCanonicalDefault_NonCanonicalBlock(
t.Error("error expected")
}
assert.Equal(libcommon.HexToHash("0x0").String(), result)
assert.Equal(common.HexToHash("0x0").String(), result)
}
func TestGetStorageAt_ByBlockHash_WithRequireCanonicalTrue_NonCanonicalBlock(t *testing.T) {
@ -201,7 +201,7 @@ func TestGetStorageAt_ByBlockHash_WithRequireCanonicalTrue_NonCanonicalBlock(t *
br := snapshotsync.NewBlockReaderWithSnapshots(m.BlockSnapshots)
stateCache := kvcache.New(kvcache.DefaultCoherentConfig)
api := NewEthAPI(NewBaseApi(nil, stateCache, br, agg, false, rpccfg.DefaultEvmCallTimeout, m.Engine), m.DB, nil, nil, nil, 5000000, 100_000)
addr := libcommon.HexToAddress("0x71562b71999873db5b286df957af199ec94617f7")
addr := common.HexToAddress("0x71562b71999873db5b286df957af199ec94617f7")
orphanedBlock := orphanedChain[0].Blocks[0]
@ -220,8 +220,8 @@ func TestCall_ByBlockHash_WithRequireCanonicalDefault_NonCanonicalBlock(t *testi
br := snapshotsync.NewBlockReaderWithSnapshots(m.BlockSnapshots)
stateCache := kvcache.New(kvcache.DefaultCoherentConfig)
api := NewEthAPI(NewBaseApi(nil, stateCache, br, agg, false, rpccfg.DefaultEvmCallTimeout, m.Engine), m.DB, nil, nil, nil, 5000000, 100_000)
from := libcommon.HexToAddress("0x71562b71999873db5b286df957af199ec94617f7")
to := libcommon.HexToAddress("0x0d3ab14bbad3d99f4203bd7a11acb94882050e7e")
from := common.HexToAddress("0x71562b71999873db5b286df957af199ec94617f7")
to := common.HexToAddress("0x0d3ab14bbad3d99f4203bd7a11acb94882050e7e")
orphanedBlock := orphanedChain[0].Blocks[0]
@ -246,8 +246,8 @@ func TestCall_ByBlockHash_WithRequireCanonicalTrue_NonCanonicalBlock(t *testing.
br := snapshotsync.NewBlockReaderWithSnapshots(m.BlockSnapshots)
stateCache := kvcache.New(kvcache.DefaultCoherentConfig)
api := NewEthAPI(NewBaseApi(nil, stateCache, br, agg, false, rpccfg.DefaultEvmCallTimeout, m.Engine), m.DB, nil, nil, nil, 5000000, 100_000)
from := libcommon.HexToAddress("0x71562b71999873db5b286df957af199ec94617f7")
to := libcommon.HexToAddress("0x0d3ab14bbad3d99f4203bd7a11acb94882050e7e")
from := common.HexToAddress("0x71562b71999873db5b286df957af199ec94617f7")
to := common.HexToAddress("0x0d3ab14bbad3d99f4203bd7a11acb94882050e7e")
orphanedBlock := orphanedChain[0].Blocks[0]

12
cmd/rpcdaemon/commands/eth_block.go
View File

@ -6,7 +6,7 @@ import (
"math/big"
"time"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common/hexutility"
"github.com/ledgerwatch/erigon-lib/kv"
"github.com/ledgerwatch/log/v3"
@ -26,7 +26,7 @@ import (
"github.com/ledgerwatch/erigon/turbo/transactions"
)
func (api *APIImpl) CallBundle(ctx context.Context, txHashes []libcommon.Hash, stateBlockNumberOrHash rpc.BlockNumberOrHash, timeoutMilliSecondsPtr *int64) (map[string]interface{}, error) {
func (api *APIImpl) CallBundle(ctx context.Context, txHashes []common.Hash, stateBlockNumberOrHash rpc.BlockNumberOrHash, timeoutMilliSecondsPtr *int64) (map[string]interface{}, error) {
tx, err := api.db.BeginRo(ctx)
if err != nil {
return nil, err
@ -182,7 +182,7 @@ func (api *APIImpl) CallBundle(ctx context.Context, txHashes []libcommon.Hash, s
if result.Err != nil {
jsonResult["error"] = result.Err.Error()
} else {
jsonResult["value"] = libcommon.BytesToHash(result.Return())
jsonResult["value"] = common.BytesToHash(result.Return())
}
results = append(results, jsonResult)
@ -222,7 +222,7 @@ func (api *APIImpl) GetBlockByNumber(ctx context.Context, number rpc.BlockNumber
return nil, err
}
var borTx types.Transaction
var borTxHash libcommon.Hash
var borTxHash common.Hash
if chainConfig.Bor != nil {
borTx, _, _, _ = rawdb.ReadBorTransactionForBlock(tx, b)
if borTx != nil {
@ -284,7 +284,7 @@ func (api *APIImpl) GetBlockByHash(ctx context.Context, numberOrHash rpc.BlockNu
return nil, err
}
var borTx types.Transaction
var borTxHash libcommon.Hash
var borTxHash common.Hash
if chainConfig.Bor != nil {
borTx, _, _, _ = rawdb.ReadBorTransactionForBlock(tx, block)
if borTx != nil {
@ -344,7 +344,7 @@ func (api *APIImpl) GetBlockTransactionCountByNumber(ctx context.Context, blockN
}
// GetBlockTransactionCountByHash implements eth_getBlockTransactionCountByHash. Returns the number of transactions in a block given the block's block hash.
func (api *APIImpl) GetBlockTransactionCountByHash(ctx context.Context, blockHash libcommon.Hash) (*hexutil.Uint, error) {
func (api *APIImpl) GetBlockTransactionCountByHash(ctx context.Context, blockHash common.Hash) (*hexutil.Uint, error) {
tx, err := api.db.BeginRo(ctx)
if err != nil {
return nil, err

26
cmd/rpcdaemon/commands/eth_block_test.go
View File

@ -5,7 +5,7 @@ import (
"math/big"
"testing"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/gointerfaces/txpool"
"github.com/ledgerwatch/erigon-lib/kv/kvcache"
"github.com/stretchr/testify/assert"
@ -30,7 +30,7 @@ func TestGetBlockByNumberWithLatestTag(t *testing.T) {
stateCache := kvcache.New(kvcache.DefaultCoherentConfig)
api := NewEthAPI(NewBaseApi(nil, stateCache, br, agg, false, rpccfg.DefaultEvmCallTimeout, m.Engine), m.DB, nil, nil, nil, 5000000, 100_000)
b, err := api.GetBlockByNumber(context.Background(), rpc.LatestBlockNumber, false)
expected := libcommon.HexToHash("0x6804117de2f3e6ee32953e78ced1db7b20214e0d8c745a03b8fecf7cc8ee76ef")
expected := common.HexToHash("0x6804117de2f3e6ee32953e78ced1db7b20214e0d8c745a03b8fecf7cc8ee76ef")
if err != nil {
t.Errorf("error getting block number with latest tag: %s", err)
}
@ -47,7 +47,7 @@ func TestGetBlockByNumberWithLatestTag_WithHeadHashInDb(t *testing.T) {
if err != nil {
t.Errorf("could not begin read write transaction: %s", err)
}
latestBlockHash := libcommon.HexToHash("0x6804117de2f3e6ee32953e78ced1db7b20214e0d8c745a03b8fecf7cc8ee76ef")
latestBlockHash := common.HexToHash("0x6804117de2f3e6ee32953e78ced1db7b20214e0d8c745a03b8fecf7cc8ee76ef")
latestBlock, err := rawdb.ReadBlockByHash(tx, latestBlockHash)
if err != nil {
tx.Rollback()
@ -55,7 +55,7 @@ func TestGetBlockByNumberWithLatestTag_WithHeadHashInDb(t *testing.T) {
}
rawdb.WriteHeaderNumber(tx, latestBlockHash, latestBlock.NonceU64())
rawdb.WriteForkchoiceHead(tx, latestBlockHash)
if safedHeadBlock := rawdb.ReadForkchoiceHead(tx); safedHeadBlock == (libcommon.Hash{}) {
if safedHeadBlock := rawdb.ReadForkchoiceHead(tx); safedHeadBlock == (common.Hash{}) {
tx.Rollback()
t.Error("didn't find forkchoice head hash")
}
@ -66,7 +66,7 @@ func TestGetBlockByNumberWithLatestTag_WithHeadHashInDb(t *testing.T) {
if err != nil {
t.Errorf("error retrieving block by number: %s", err)
}
expectedHash := libcommon.HexToHash("0x71b89b6ca7b65debfd2fbb01e4f07de7bba343e6617559fa81df19b605f84662")
expectedHash := common.HexToHash("0x71b89b6ca7b65debfd2fbb01e4f07de7bba343e6617559fa81df19b605f84662")
assert.Equal(t, expectedHash, block["hash"])
}
@ -123,7 +123,7 @@ func TestGetBlockByNumber_WithFinalizedTag_WithFinalizedBlockInDb(t *testing.T)
if err != nil {
t.Errorf("could not begin read write transaction: %s", err)
}
latestBlockHash := libcommon.HexToHash("0x6804117de2f3e6ee32953e78ced1db7b20214e0d8c745a03b8fecf7cc8ee76ef")
latestBlockHash := common.HexToHash("0x6804117de2f3e6ee32953e78ced1db7b20214e0d8c745a03b8fecf7cc8ee76ef")
latestBlock, err := rawdb.ReadBlockByHash(tx, latestBlockHash)
if err != nil {
tx.Rollback()
@ -131,7 +131,7 @@ func TestGetBlockByNumber_WithFinalizedTag_WithFinalizedBlockInDb(t *testing.T)
}
rawdb.WriteHeaderNumber(tx, latestBlockHash, latestBlock.NonceU64())
rawdb.WriteForkchoiceFinalized(tx, latestBlockHash)
if safedFinalizedBlock := rawdb.ReadForkchoiceFinalized(tx); safedFinalizedBlock == (libcommon.Hash{}) {
if safedFinalizedBlock := rawdb.ReadForkchoiceFinalized(tx); safedFinalizedBlock == (common.Hash{}) {
tx.Rollback()
t.Error("didn't find forkchoice finalized hash")
}
@ -142,7 +142,7 @@ func TestGetBlockByNumber_WithFinalizedTag_WithFinalizedBlockInDb(t *testing.T)
if err != nil {
t.Errorf("error retrieving block by number: %s", err)
}
expectedHash := libcommon.HexToHash("0x71b89b6ca7b65debfd2fbb01e4f07de7bba343e6617559fa81df19b605f84662")
expectedHash := common.HexToHash("0x71b89b6ca7b65debfd2fbb01e4f07de7bba343e6617559fa81df19b605f84662")
assert.Equal(t, expectedHash, block["hash"])
}
@ -168,7 +168,7 @@ func TestGetBlockByNumber_WithSafeTag_WithSafeBlockInDb(t *testing.T) {
if err != nil {
t.Errorf("could not begin read write transaction: %s", err)
}
latestBlockHash := libcommon.HexToHash("0x6804117de2f3e6ee32953e78ced1db7b20214e0d8c745a03b8fecf7cc8ee76ef")
latestBlockHash := common.HexToHash("0x6804117de2f3e6ee32953e78ced1db7b20214e0d8c745a03b8fecf7cc8ee76ef")
latestBlock, err := rawdb.ReadBlockByHash(tx, latestBlockHash)
if err != nil {
tx.Rollback()
@ -176,7 +176,7 @@ func TestGetBlockByNumber_WithSafeTag_WithSafeBlockInDb(t *testing.T) {
}
rawdb.WriteHeaderNumber(tx, latestBlockHash, latestBlock.NonceU64())
rawdb.WriteForkchoiceSafe(tx, latestBlockHash)
if safedSafeBlock := rawdb.ReadForkchoiceSafe(tx); safedSafeBlock == (libcommon.Hash{}) {
if safedSafeBlock := rawdb.ReadForkchoiceSafe(tx); safedSafeBlock == (common.Hash{}) {
tx.Rollback()
t.Error("didn't find forkchoice safe block hash")
}
@ -187,7 +187,7 @@ func TestGetBlockByNumber_WithSafeTag_WithSafeBlockInDb(t *testing.T) {
if err != nil {
t.Errorf("error retrieving block by number: %s", err)
}
expectedHash := libcommon.HexToHash("0x71b89b6ca7b65debfd2fbb01e4f07de7bba343e6617559fa81df19b605f84662")
expectedHash := common.HexToHash("0x71b89b6ca7b65debfd2fbb01e4f07de7bba343e6617559fa81df19b605f84662")
assert.Equal(t, expectedHash, block["hash"])
}
@ -199,7 +199,7 @@ func TestGetBlockTransactionCountByHash(t *testing.T) {
stateCache := kvcache.New(kvcache.DefaultCoherentConfig)
api := NewEthAPI(NewBaseApi(nil, stateCache, br, agg, false, rpccfg.DefaultEvmCallTimeout, m.Engine), m.DB, nil, nil, nil, 5000000, 100_000)
blockHash := libcommon.HexToHash("0x6804117de2f3e6ee32953e78ced1db7b20214e0d8c745a03b8fecf7cc8ee76ef")
blockHash := common.HexToHash("0x6804117de2f3e6ee32953e78ced1db7b20214e0d8c745a03b8fecf7cc8ee76ef")
tx, err := m.DB.BeginRw(ctx)
if err != nil {
@ -234,7 +234,7 @@ func TestGetBlockTransactionCountByNumber(t *testing.T) {
ctx := context.Background()
stateCache := kvcache.New(kvcache.DefaultCoherentConfig)
api := NewEthAPI(NewBaseApi(nil, stateCache, br, agg, false, rpccfg.DefaultEvmCallTimeout, m.Engine), m.DB, nil, nil, nil, 5000000, 100_000)
blockHash := libcommon.HexToHash("0x6804117de2f3e6ee32953e78ced1db7b20214e0d8c745a03b8fecf7cc8ee76ef")
blockHash := common.HexToHash("0x6804117de2f3e6ee32953e78ced1db7b20214e0d8c745a03b8fecf7cc8ee76ef")
tx, err := m.DB.BeginRw(ctx)
if err != nil {

3
cmd/rpcdaemon/commands/eth_call.go
View File

@ -15,7 +15,6 @@ import (
"github.com/ledgerwatch/log/v3"
"google.golang.org/grpc"
"github.com/ledgerwatch/erigon/common"
"github.com/ledgerwatch/erigon/common/hexutil"
"github.com/ledgerwatch/erigon/core"
"github.com/ledgerwatch/erigon/core/state"
@ -172,7 +171,7 @@ func (api *APIImpl) EstimateGas(ctx context.Context, argsOrNil *ethapi2.CallArgs
} else if args.MaxFeePerGas != nil {
feeCap = args.MaxFeePerGas.ToInt()
} else {
feeCap = common.Big0
feeCap = libcommon.Big0
}
// Recap the highest gas limit with account's available balance.
if feeCap.Sign() != 0 {

16
cmd/rpcdaemon/commands/eth_callMany.go
View File

@ -8,7 +8,7 @@ import (
"time"
"github.com/holiman/uint256"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/log/v3"
"github.com/ledgerwatch/erigon/common/hexutil"
@ -26,12 +26,12 @@ import (
type BlockOverrides struct {
BlockNumber *hexutil.Uint64
Coinbase *libcommon.Address
Coinbase *common.Address
Timestamp *hexutil.Uint64
GasLimit *hexutil.Uint
Difficulty *hexutil.Uint
BaseFee *uint256.Int
BlockHash *map[uint64]libcommon.Hash
BlockHash *map[uint64]common.Hash
}
type Bundle struct {
@ -44,7 +44,7 @@ type StateContext struct {
TransactionIndex *int
}
func blockHeaderOverride(blockCtx *evmtypes.BlockContext, blockOverride BlockOverrides, overrideBlockHash map[uint64]libcommon.Hash) {
func blockHeaderOverride(blockCtx *evmtypes.BlockContext, blockOverride BlockOverrides, overrideBlockHash map[uint64]common.Hash) {
if blockOverride.BlockNumber != nil {
blockCtx.BlockNumber = uint64(*blockOverride.BlockNumber)
}
@ -72,16 +72,16 @@ func blockHeaderOverride(blockCtx *evmtypes.BlockContext, blockOverride BlockOve
func (api *APIImpl) CallMany(ctx context.Context, bundles []Bundle, simulateContext StateContext, stateOverride *ethapi.StateOverrides, timeoutMilliSecondsPtr *int64) ([][]map[string]interface{}, error) {
var (
hash libcommon.Hash
hash common.Hash
replayTransactions types.Transactions
evm *vm.EVM
blockCtx evmtypes.BlockContext
txCtx evmtypes.TxContext
overrideBlockHash map[uint64]libcommon.Hash
overrideBlockHash map[uint64]common.Hash
baseFee uint256.Int
)
overrideBlockHash = make(map[uint64]libcommon.Hash)
overrideBlockHash = make(map[uint64]common.Hash)
tx, err := api.db.BeginRo(ctx)
if err != nil {
return nil, err
@ -145,7 +145,7 @@ func (api *APIImpl) CallMany(ctx context.Context, bundles []Bundle, simulateCont
return nil, fmt.Errorf("block %d(%x) not found", blockNum, hash)
}
getHash := func(i uint64) libcommon.Hash {
getHash := func(i uint64) common.Hash {
if hash, ok := overrideBlockHash[i]; ok {
return hash
}

12
cmd/rpcdaemon/commands/eth_deprecated.go
View File

@ -4,24 +4,24 @@ import (
"context"
"fmt"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon/common/hexutil"
)
// Accounts implements eth_accounts. Returns a list of addresses owned by the client.
// Deprecated: This function will be removed in the future.
func (api *APIImpl) Accounts(ctx context.Context) ([]libcommon.Address, error) {
return []libcommon.Address{}, fmt.Errorf(NotAvailableDeprecated, "eth_accounts")
func (api *APIImpl) Accounts(ctx context.Context) ([]common.Address, error) {
return []common.Address{}, fmt.Errorf(NotAvailableDeprecated, "eth_accounts")
}
// Sign implements eth_sign. Calculates an Ethereum specific signature with: sign(keccak256('\\x19Ethereum Signed Message:\\n' + len(message) + message))).
// Deprecated: This function will be removed in the future.
func (api *APIImpl) Sign(ctx context.Context, _ libcommon.Address, _ hexutil.Bytes) (hexutil.Bytes, error) {
func (api *APIImpl) Sign(ctx context.Context, _ common.Address, _ hexutil.Bytes) (hexutil.Bytes, error) {
return hexutil.Bytes(""), fmt.Errorf(NotAvailableDeprecated, "eth_sign")
}
// SignTransaction deprecated
func (api *APIImpl) SignTransaction(_ context.Context, txObject interface{}) (libcommon.Hash, error) {
return libcommon.Hash{0}, fmt.Errorf(NotAvailableDeprecated, "eth_signTransaction")
func (api *APIImpl) SignTransaction(_ context.Context, txObject interface{}) (common.Hash, error) {
return common.Hash{0}, fmt.Errorf(NotAvailableDeprecated, "eth_signTransaction")
}

12
cmd/rpcdaemon/commands/eth_txs.go
View File

@ -5,7 +5,7 @@ import (
"context"
"math/big"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/gointerfaces"
"github.com/ledgerwatch/erigon-lib/gointerfaces/txpool"
"github.com/ledgerwatch/erigon-lib/gointerfaces/types"
@ -19,7 +19,7 @@ import (
)
// GetTransactionByHash implements eth_getTransactionByHash. Returns information about a transaction given the transaction's hash.
func (api *APIImpl) GetTransactionByHash(ctx context.Context, txnHash libcommon.Hash) (*RPCTransaction, error) {
func (api *APIImpl) GetTransactionByHash(ctx context.Context, txnHash common.Hash) (*RPCTransaction, error) {
tx, err := api.db.BeginRo(ctx)
if err != nil {
return nil, err
@ -67,7 +67,7 @@ func (api *APIImpl) GetTransactionByHash(ctx context.Context, txnHash libcommon.
// Add GasPrice for the DynamicFeeTransaction
var baseFee *big.Int
if chainConfig.IsLondon(blockNum) && blockHash != (libcommon.Hash{}) {
if chainConfig.IsLondon(blockNum) && blockHash != (common.Hash{}) {
baseFee = block.BaseFee()
}
@ -116,7 +116,7 @@ func (api *APIImpl) GetTransactionByHash(ctx context.Context, txnHash libcommon.
}
// GetRawTransactionByHash returns the bytes of the transaction for the given hash.
func (api *APIImpl) GetRawTransactionByHash(ctx context.Context, hash libcommon.Hash) (hexutil.Bytes, error) {
func (api *APIImpl) GetRawTransactionByHash(ctx context.Context, hash common.Hash) (hexutil.Bytes, error) {
tx, err := api.db.BeginRo(ctx)
if err != nil {
return nil, err
@ -164,7 +164,7 @@ func (api *APIImpl) GetRawTransactionByHash(ctx context.Context, hash libcommon.
}
// GetTransactionByBlockHashAndIndex implements eth_getTransactionByBlockHashAndIndex. Returns information about a transaction given the block's hash and a transaction index.
func (api *APIImpl) GetTransactionByBlockHashAndIndex(ctx context.Context, blockHash libcommon.Hash, txIndex hexutil.Uint64) (*RPCTransaction, error) {
func (api *APIImpl) GetTransactionByBlockHashAndIndex(ctx context.Context, blockHash common.Hash, txIndex hexutil.Uint64) (*RPCTransaction, error) {
tx, err := api.db.BeginRo(ctx)
if err != nil {
return nil, err
@ -203,7 +203,7 @@ func (api *APIImpl) GetTransactionByBlockHashAndIndex(ctx context.Context, block
}
// GetRawTransactionByBlockHashAndIndex returns the bytes of the transaction for the given block hash and index.
func (api *APIImpl) GetRawTransactionByBlockHashAndIndex(ctx context.Context, blockHash libcommon.Hash, index hexutil.Uint) (hexutil.Bytes, error) {
func (api *APIImpl) GetRawTransactionByBlockHashAndIndex(ctx context.Context, blockHash common.Hash, index hexutil.Uint) (hexutil.Bytes, error) {
tx, err := api.db.BeginRo(ctx)
if err != nil {
return nil, err

6
cmd/rpcdaemon/commands/eth_uncles.go
View File

@ -3,7 +3,7 @@ package commands
import (
"context"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/log/v3"
"github.com/ledgerwatch/erigon/common/hexutil"
@ -50,7 +50,7 @@ func (api *APIImpl) GetUncleByBlockNumberAndIndex(ctx context.Context, number rp
}
// GetUncleByBlockHashAndIndex implements eth_getUncleByBlockHashAndIndex. Returns information about an uncle given a block's hash and the index of the uncle.
func (api *APIImpl) GetUncleByBlockHashAndIndex(ctx context.Context, hash libcommon.Hash, index hexutil.Uint) (map[string]interface{}, error) {
func (api *APIImpl) GetUncleByBlockHashAndIndex(ctx context.Context, hash common.Hash, index hexutil.Uint) (map[string]interface{}, error) {
tx, err := api.db.BeginRo(ctx)
if err != nil {
return nil, err
@ -109,7 +109,7 @@ func (api *APIImpl) GetUncleCountByBlockNumber(ctx context.Context, number rpc.B
}
// GetUncleCountByBlockHash implements eth_getUncleCountByBlockHash. Returns the number of uncles in the block, if any.
func (api *APIImpl) GetUncleCountByBlockHash(ctx context.Context, hash libcommon.Hash) (*hexutil.Uint, error) {
func (api *APIImpl) GetUncleCountByBlockHash(ctx context.Context, hash common.Hash) (*hexutil.Uint, error) {
n := hexutil.Uint(0)
tx, err := api.db.BeginRo(ctx)
if err != nil {

26
cmd/rpcdaemon/commands/send_transaction.go
View File

@ -7,7 +7,7 @@ import (
"fmt"
"math/big"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common"
txPoolProto "github.com/ledgerwatch/erigon-lib/gointerfaces/txpool"
"github.com/ledgerwatch/log/v3"
@ -21,24 +21,24 @@ import (
)
// SendRawTransaction implements eth_sendRawTransaction. Creates new message call transaction or a contract creation for previously-signed transactions.
func (api *APIImpl) SendRawTransaction(ctx context.Context, encodedTx hexutil.Bytes) (libcommon.Hash, error) {
func (api *APIImpl) SendRawTransaction(ctx context.Context, encodedTx hexutil.Bytes) (common.Hash, error) {
txn, err := types.DecodeTransaction(rlp.NewStream(bytes.NewReader(encodedTx), uint64(len(encodedTx))))
if err != nil {
return libcommon.Hash{}, err
return common.Hash{}, err
}
// If the transaction fee cap is already specified, ensure the
// fee of the given transaction is _reasonable_.
if err := checkTxFee(txn.GetPrice().ToBig(), txn.GetGas(), ethconfig.Defaults.RPCTxFeeCap); err != nil {
return libcommon.Hash{}, err
return common.Hash{}, err
}
if !txn.Protected() {
return libcommon.Hash{}, errors.New("only replay-protected (EIP-155) transactions allowed over RPC")
return common.Hash{}, errors.New("only replay-protected (EIP-155) transactions allowed over RPC")
}
hash := txn.Hash()
res, err := api.txPool.Add(ctx, &txPoolProto.AddRequest{RlpTxs: [][]byte{encodedTx}})
if err != nil {
return libcommon.Hash{}, err
return common.Hash{}, err
}
if res.Imported[0] != txPoolProto.ImportResult_SUCCESS {
@ -47,31 +47,31 @@ func (api *APIImpl) SendRawTransaction(ctx context.Context, encodedTx hexutil.By
tx, err := api.db.BeginRo(ctx)
if err != nil {
return libcommon.Hash{}, err
return common.Hash{}, err
}
defer tx.Rollback()
// Print a log with full txn details for manual investigations and interventions
blockNum := rawdb.ReadCurrentBlockNumber(tx)
if blockNum == nil {
return libcommon.Hash{}, err
return common.Hash{}, err
}
cc, err := api.chainConfig(tx)
if err != nil {
return libcommon.Hash{}, err
return common.Hash{}, err
}
txnChainId := txn.GetChainID()
chainId := cc.ChainID
if chainId.Cmp(txnChainId.ToBig()) != 0 {
return libcommon.Hash{}, fmt.Errorf("invalid chain id, expected: %d got: %d", chainId, *txnChainId)
return common.Hash{}, fmt.Errorf("invalid chain id, expected: %d got: %d", chainId, *txnChainId)
}
signer := types.MakeSigner(cc, *blockNum)
from, err := txn.Sender(*signer)
if err != nil {
return libcommon.Hash{}, err
return common.Hash{}, err
}
if txn.GetTo() == nil {
@ -85,8 +85,8 @@ func (api *APIImpl) SendRawTransaction(ctx context.Context, encodedTx hexutil.By
}
// SendTransaction implements eth_sendTransaction. Creates new message call transaction or a contract creation if the data field contains code.
func (api *APIImpl) SendTransaction(_ context.Context, txObject interface{}) (libcommon.Hash, error) {
return libcommon.Hash{0}, fmt.Errorf(NotImplemented, "eth_sendTransaction")
func (api *APIImpl) SendTransaction(_ context.Context, txObject interface{}) (common.Hash, error) {
return common.Hash{0}, fmt.Errorf(NotImplemented, "eth_sendTransaction")
}
// checkTxFee is an internal function used to check whether the fee of

8
cmd/rpcdaemon/commands/send_transaction_test.go
View File

@ -7,7 +7,7 @@ import (
"testing"
"github.com/holiman/uint256"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/gointerfaces/sentry"
"github.com/ledgerwatch/erigon-lib/gointerfaces/txpool"
"github.com/ledgerwatch/erigon-lib/kv/kvcache"
@ -32,7 +32,7 @@ func TestSendRawTransaction(t *testing.T) {
m, require := stages.Mock(t), require.New(t)
chain, err := core.GenerateChain(m.ChainConfig, m.Genesis, m.Engine, m.DB, 1, func(i int, b *core.BlockGen) {
b.SetCoinbase(libcommon.Address{1})
b.SetCoinbase(common.Address{1})
}, false /* intermediateHashes */)
require.NoError(err)
{ // Do 1 step to start txPool
@ -66,7 +66,7 @@ func TestSendRawTransaction(t *testing.T) {
}
expectValue := uint64(1234)
txn, err := types.SignTx(types.NewTransaction(0, libcommon.Address{1}, uint256.NewInt(expectValue), params.TxGas, uint256.NewInt(10*params.GWei), nil), *types.LatestSignerForChainID(m.ChainConfig.ChainID), m.Key)
txn, err := types.SignTx(types.NewTransaction(0, common.Address{1}, uint256.NewInt(expectValue), params.TxGas, uint256.NewInt(10*params.GWei), nil), *types.LatestSignerForChainID(m.ChainConfig.ChainID), m.Key)
require.NoError(err)
ctx, conn := rpcdaemontest.CreateTestGrpcConn(t, m)
@ -106,6 +106,6 @@ func transaction(nonce uint64, gaslimit uint64, key *ecdsa.PrivateKey) types.Tra
}
func pricedTransaction(nonce uint64, gaslimit uint64, gasprice *uint256.Int, key *ecdsa.PrivateKey) types.Transaction {
tx, _ := types.SignTx(types.NewTransaction(nonce, libcommon.Address{}, uint256.NewInt(100), gaslimit, gasprice, nil), *types.LatestSignerForChainID(big.NewInt(1337)), key)
tx, _ := types.SignTx(types.NewTransaction(nonce, common.Address{}, uint256.NewInt(100), gaslimit, gasprice, nil), *types.LatestSignerForChainID(big.NewInt(1337)), key)
return tx
}

53
cmd/rpcdaemon/commands/trace_filtering.go
View File

@ -9,13 +9,12 @@ import (
"github.com/RoaringBitmap/roaring/roaring64"
jsoniter "github.com/json-iterator/go"
"github.com/ledgerwatch/erigon-lib/chain"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/kv"
"github.com/ledgerwatch/erigon-lib/kv/bitmapdb"
"github.com/ledgerwatch/erigon-lib/kv/iter"
"github.com/ledgerwatch/erigon-lib/kv/order"
"github.com/ledgerwatch/erigon-lib/kv/rawdbv3"
"github.com/ledgerwatch/erigon/common"
"github.com/ledgerwatch/erigon/common/hexutil"
"github.com/ledgerwatch/erigon/consensus/ethash"
"github.com/ledgerwatch/erigon/core"
@ -32,7 +31,7 @@ import (
)
// Transaction implements trace_transaction
func (api *TraceAPIImpl) Transaction(ctx context.Context, txHash libcommon.Hash) (ParityTraces, error) {
func (api *TraceAPIImpl) Transaction(ctx context.Context, txHash common.Hash) (ParityTraces, error) {
tx, err := api.kv.BeginRo(ctx)
if err != nil {
return nil, err
@ -119,7 +118,7 @@ func (api *TraceAPIImpl) Transaction(ctx context.Context, txHash libcommon.Hash)
}
// Get implements trace_get
func (api *TraceAPIImpl) Get(ctx context.Context, txHash libcommon.Hash, indicies []hexutil.Uint64) (*ParityTrace, error) {
func (api *TraceAPIImpl) Get(ctx context.Context, txHash common.Hash, indicies []hexutil.Uint64) (*ParityTrace, error) {
// Parity fails if it gets more than a single index. It returns nothing in this case. Must we?
if len(indicies) > 1 {
return nil, nil
@ -205,7 +204,7 @@ func (api *TraceAPIImpl) Block(ctx context.Context, blockNr rpc.BlockNumber) (Pa
rewardAction.Value.ToInt().Set(minerReward.ToBig())
}
tr.Action = rewardAction
tr.BlockHash = &libcommon.Hash{}
tr.BlockHash = &common.Hash{}
copy(tr.BlockHash[:], block.Hash().Bytes())
tr.BlockNumber = new(uint64)
*tr.BlockNumber = block.NumberU64()
@ -223,7 +222,7 @@ func (api *TraceAPIImpl) Block(ctx context.Context, blockNr rpc.BlockNumber) (Pa
rewardAction.RewardType = "uncle" // nolint: goconst
rewardAction.Value.ToInt().Set(uncleRewards[i].ToBig())
tr.Action = rewardAction
tr.BlockHash = &libcommon.Hash{}
tr.BlockHash = &common.Hash{}
copy(tr.BlockHash[:], block.Hash().Bytes())
tr.BlockNumber = new(uint64)
*tr.BlockNumber = block.NumberU64()
@ -237,9 +236,9 @@ func (api *TraceAPIImpl) Block(ctx context.Context, blockNr rpc.BlockNumber) (Pa
return out, err
}
func traceFilterBitmaps(tx kv.Tx, req TraceFilterRequest, from, to uint64) (fromAddresses, toAddresses map[libcommon.Address]struct{}, allBlocks *roaring64.Bitmap, err error) {
fromAddresses = make(map[libcommon.Address]struct{}, len(req.FromAddress))
toAddresses = make(map[libcommon.Address]struct{}, len(req.ToAddress))
func traceFilterBitmaps(tx kv.Tx, req TraceFilterRequest, from, to uint64) (fromAddresses, toAddresses map[common.Address]struct{}, allBlocks *roaring64.Bitmap, err error) {
fromAddresses = make(map[common.Address]struct{}, len(req.FromAddress))
toAddresses = make(map[common.Address]struct{}, len(req.ToAddress))
allBlocks = roaring64.New()
var blocksTo roaring64.Bitmap
for _, addr := range req.FromAddress {
@ -290,9 +289,9 @@ func traceFilterBitmaps(tx kv.Tx, req TraceFilterRequest, from, to uint64) (from
return fromAddresses, toAddresses, allBlocks, nil
}
func traceFilterBitmapsV3(tx kv.TemporalTx, req TraceFilterRequest, from, to uint64) (fromAddresses, toAddresses map[libcommon.Address]struct{}, allBlocks iter.U64, err error) {
fromAddresses = make(map[libcommon.Address]struct{}, len(req.FromAddress))
toAddresses = make(map[libcommon.Address]struct{}, len(req.ToAddress))
func traceFilterBitmapsV3(tx kv.TemporalTx, req TraceFilterRequest, from, to uint64) (fromAddresses, toAddresses map[common.Address]struct{}, allBlocks iter.U64, err error) {
fromAddresses = make(map[common.Address]struct{}, len(req.FromAddress))
toAddresses = make(map[common.Address]struct{}, len(req.ToAddress))
var blocksTo iter.U64
for _, addr := range req.FromAddress {
@ -508,7 +507,7 @@ func (api *TraceAPIImpl) Filter(ctx context.Context, req TraceFilterRequest, str
rewardAction.RewardType = "block" // nolint: goconst
rewardAction.Value.ToInt().Set(minerReward.ToBig())
tr.Action = rewardAction
tr.BlockHash = &libcommon.Hash{}
tr.BlockHash = &common.Hash{}
copy(tr.BlockHash[:], block.Hash().Bytes())
tr.BlockNumber = new(uint64)
*tr.BlockNumber = block.NumberU64()
@ -546,7 +545,7 @@ func (api *TraceAPIImpl) Filter(ctx context.Context, req TraceFilterRequest, str
rewardAction.RewardType = "uncle" // nolint: goconst
rewardAction.Value.ToInt().Set(uncleRewards[i].ToBig())
tr.Action = rewardAction
tr.BlockHash = &libcommon.Hash{}
tr.BlockHash = &common.Hash{}
copy(tr.BlockHash[:], block.Hash().Bytes())
tr.BlockNumber = new(uint64)
*tr.BlockNumber = block.NumberU64()
@ -625,7 +624,7 @@ func (api *TraceAPIImpl) filterV3(ctx context.Context, dbtx kv.TemporalTx, fromB
includeAll := len(fromAddresses) == 0 && len(toAddresses) == 0
it := MapTxNum2BlockNum(dbtx, allTxs)
var lastBlockHash libcommon.Hash
var lastBlockHash common.Hash
var lastHeader *types.Header
var lastSigner *types.Signer
var lastRules *chain.Rules
@ -699,7 +698,7 @@ func (api *TraceAPIImpl) filterV3(ctx context.Context, dbtx kv.TemporalTx, fromB
rewardAction.RewardType = "block" // nolint: goconst
rewardAction.Value.ToInt().Set(minerReward.ToBig())
tr.Action = rewardAction
tr.BlockHash = &libcommon.Hash{}
tr.BlockHash = &common.Hash{}
copy(tr.BlockHash[:], lastBlockHash.Bytes())
tr.BlockNumber = new(uint64)
*tr.BlockNumber = blockNum
@ -737,7 +736,7 @@ func (api *TraceAPIImpl) filterV3(ctx context.Context, dbtx kv.TemporalTx, fromB
rewardAction.RewardType = "uncle" // nolint: goconst
rewardAction.Value.ToInt().Set(uncleRewards[i].ToBig())
tr.Action = rewardAction
tr.BlockHash = &libcommon.Hash{}
tr.BlockHash = &common.Hash{}
copy(tr.BlockHash[:], lastBlockHash[:])
tr.BlockNumber = new(uint64)
*tr.BlockNumber = blockNum
@ -836,7 +835,7 @@ func (api *TraceAPIImpl) filterV3(ctx context.Context, dbtx kv.TemporalTx, fromB
stream.WriteObjectEnd()
continue
}
traceResult.Output = libcommon.Copy(execResult.ReturnData)
traceResult.Output = common.Copy(execResult.ReturnData)
if err = ibs.FinalizeTx(evm.ChainRules(), noop); err != nil {
if first {
first = false
@ -894,7 +893,7 @@ func (api *TraceAPIImpl) filterV3(ctx context.Context, dbtx kv.TemporalTx, fromB
return stream.Flush()
}
func filter_trace(pt *ParityTrace, fromAddresses map[libcommon.Address]struct{}, toAddresses map[libcommon.Address]struct{}) bool {
func filter_trace(pt *ParityTrace, fromAddresses map[common.Address]struct{}, toAddresses map[common.Address]struct{}) bool {
switch action := pt.Action.(type) {
case *CallTraceAction:
_, f := fromAddresses[action.From]
@ -926,7 +925,7 @@ func filter_trace(pt *ParityTrace, fromAddresses map[libcommon.Address]struct{},
return false
}
func (api *TraceAPIImpl) callManyTransactions(ctx context.Context, dbtx kv.Tx, txs []types.Transaction, traceTypes []string, parentHash libcommon.Hash, parentNo rpc.BlockNumber, header *types.Header, txIndex int, signer *types.Signer, rules *chain.Rules) ([]*TraceCallResult, error) {
func (api *TraceAPIImpl) callManyTransactions(ctx context.Context, dbtx kv.Tx, txs []types.Transaction, traceTypes []string, parentHash common.Hash, parentNo rpc.BlockNumber, header *types.Header, txIndex int, signer *types.Signer, rules *chain.Rules) ([]*TraceCallResult, error) {
callParams := make([]TraceCallParam, 0, len(txs))
msgs := make([]types.Message, len(txs))
for i, tx := range txs {
@ -956,13 +955,13 @@ func (api *TraceAPIImpl) callManyTransactions(ctx context.Context, dbtx kv.Tx, t
// TraceFilterRequest represents the arguments for trace_filter
type TraceFilterRequest struct {
FromBlock *hexutil.Uint64 `json:"fromBlock"`
ToBlock *hexutil.Uint64 `json:"toBlock"`
FromAddress []*libcommon.Address `json:"fromAddress"`
ToAddress []*libcommon.Address `json:"toAddress"`
Mode TraceFilterMode `json:"mode"`
After *uint64 `json:"after"`
Count *uint64 `json:"count"`
FromBlock *hexutil.Uint64 `json:"fromBlock"`
ToBlock *hexutil.Uint64 `json:"toBlock"`
FromAddress []*common.Address `json:"fromAddress"`
ToAddress []*common.Address `json:"toAddress"`
Mode TraceFilterMode `json:"mode"`
After *uint64 `json:"after"`
Count *uint64 `json:"count"`
}
type TraceFilterMode string

86
cmd/rpcdaemon/commands/trace_types.go
View File

@ -3,7 +3,7 @@ package commands
import (
"fmt"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon/common/hexutil"
"github.com/ledgerwatch/erigon/core/types"
@ -38,16 +38,16 @@ type GethTraces []*GethTrace
// ParityTrace A trace in the desired format (Parity/OpenEtherum) See: https://openethereum.github.io/wiki/JSONRPC-trace-module
type ParityTrace struct {
// Do not change the ordering of these fields -- allows for easier comparison with other clients
Action interface{} `json:"action"` // Can be either CallTraceAction or CreateTraceAction
BlockHash *libcommon.Hash `json:"blockHash,omitempty"`
BlockNumber *uint64 `json:"blockNumber,omitempty"`
Error string `json:"error,omitempty"`
Result interface{} `json:"result"`
Subtraces int `json:"subtraces"`
TraceAddress []int `json:"traceAddress"`
TransactionHash *libcommon.Hash `json:"transactionHash,omitempty"`
TransactionPosition *uint64 `json:"transactionPosition,omitempty"`
Type string `json:"type"`
Action interface{} `json:"action"` // Can be either CallTraceAction or CreateTraceAction
BlockHash *common.Hash `json:"blockHash,omitempty"`
BlockNumber *uint64 `json:"blockNumber,omitempty"`
Error string `json:"error,omitempty"`
Result interface{} `json:"result"`
Subtraces int `json:"subtraces"`
TraceAddress []int `json:"traceAddress"`
TransactionHash *common.Hash `json:"transactionHash,omitempty"`
TransactionPosition *uint64 `json:"transactionPosition,omitempty"`
Type string `json:"type"`
}
// ParityTraces An array of parity traces
@ -56,53 +56,53 @@ type ParityTraces []ParityTrace
// TraceAction A parity formatted trace action
type TraceAction struct {
// Do not change the ordering of these fields -- allows for easier comparison with other clients
Author string `json:"author,omitempty"`
RewardType string `json:"rewardType,omitempty"`
SelfDestructed string `json:"address,omitempty"`
Balance string `json:"balance,omitempty"`
CallType string `json:"callType,omitempty"`
From libcommon.Address `json:"from"`
Gas hexutil.Big `json:"gas"`
Init hexutil.Bytes `json:"init,omitempty"`
Input hexutil.Bytes `json:"input,omitempty"`
RefundAddress string `json:"refundAddress,omitempty"`
To string `json:"to,omitempty"`
Value string `json:"value,omitempty"`
Author string `json:"author,omitempty"`
RewardType string `json:"rewardType,omitempty"`
SelfDestructed string `json:"address,omitempty"`
Balance string `json:"balance,omitempty"`
CallType string `json:"callType,omitempty"`
From common.Address `json:"from"`
Gas hexutil.Big `json:"gas"`
Init hexutil.Bytes `json:"init,omitempty"`
Input hexutil.Bytes `json:"input,omitempty"`
RefundAddress string `json:"refundAddress,omitempty"`
To string `json:"to,omitempty"`
Value string `json:"value,omitempty"`
}
type CallTraceAction struct {
From libcommon.Address `json:"from"`
CallType string `json:"callType"`
Gas hexutil.Big `json:"gas"`
Input hexutil.Bytes `json:"input"`
To libcommon.Address `json:"to"`
Value hexutil.Big `json:"value"`
From common.Address `json:"from"`
CallType string `json:"callType"`
Gas hexutil.Big `json:"gas"`
Input hexutil.Bytes `json:"input"`
To common.Address `json:"to"`
Value hexutil.Big `json:"value"`
}
type CreateTraceAction struct {
From libcommon.Address `json:"from"`
Gas hexutil.Big `json:"gas"`
Init hexutil.Bytes `json:"init"`
Value hexutil.Big `json:"value"`
From common.Address `json:"from"`
Gas hexutil.Big `json:"gas"`
Init hexutil.Bytes `json:"init"`
Value hexutil.Big `json:"value"`
}
type SuicideTraceAction struct {
Address libcommon.Address `json:"address"`
RefundAddress libcommon.Address `json:"refundAddress"`
Balance hexutil.Big `json:"balance"`
Address common.Address `json:"address"`
RefundAddress common.Address `json:"refundAddress"`
Balance hexutil.Big `json:"balance"`
}
type RewardTraceAction struct {
Author libcommon.Address `json:"author"`
RewardType string `json:"rewardType"`
Value hexutil.Big `json:"value,omitempty"`
Author common.Address `json:"author"`
RewardType string `json:"rewardType"`
Value hexutil.Big `json:"value,omitempty"`
}
type CreateTraceResult struct {
// Do not change the ordering of these fields -- allows for easier comparison with other clients
Address *libcommon.Address `json:"address,omitempty"`
Code hexutil.Bytes `json:"code"`
GasUsed *hexutil.Big `json:"gasUsed"`
Address *common.Address `json:"address,omitempty"`
Code hexutil.Bytes `json:"code"`
GasUsed *hexutil.Big `json:"gasUsed"`
}
// TraceResult A parity formatted trace result
@ -155,7 +155,7 @@ func (t ParityTrace) String() string {
// Takes a hierarchical Geth trace with fields of different meaning stored in the same named fields depending on 'type'. Parity traces
// are flattened depth first and each field is put in its proper place
func (api *TraceAPIImpl) convertToParityTrace(gethTrace GethTrace, blockHash libcommon.Hash, blockNumber uint64, tx types.Transaction, txIndex uint64, depth []int) ParityTraces { //nolint: unused
func (api *TraceAPIImpl) convertToParityTrace(gethTrace GethTrace, blockHash common.Hash, blockNumber uint64, tx types.Transaction, txIndex uint64, depth []int) ParityTraces { //nolint: unused
var traces ParityTraces // nolint prealloc
return traces
}

20
cmd/rpcdaemon/commands/tracing.go
View File

@ -8,7 +8,7 @@ import (
"github.com/holiman/uint256"
jsoniter "github.com/json-iterator/go"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/log/v3"
"github.com/ledgerwatch/erigon/core/vm/evmtypes"
@ -33,7 +33,7 @@ func (api *PrivateDebugAPIImpl) TraceBlockByNumber(ctx context.Context, blockNum
}
// TraceBlockByHash implements debug_traceBlockByHash. Returns Geth style block traces.
func (api *PrivateDebugAPIImpl) TraceBlockByHash(ctx context.Context, hash libcommon.Hash, config *tracers.TraceConfig, stream *jsoniter.Stream) error {
func (api *PrivateDebugAPIImpl) TraceBlockByHash(ctx context.Context, hash common.Hash, config *tracers.TraceConfig, stream *jsoniter.Stream) error {
return api.traceBlock(ctx, rpc.BlockNumberOrHashWithHash(hash, true), config, stream)
}
@ -48,7 +48,7 @@ func (api *PrivateDebugAPIImpl) traceBlock(ctx context.Context, blockNrOrHash rp
block *types.Block
number rpc.BlockNumber
numberOk bool
hash libcommon.Hash
hash common.Hash
hashOk bool
)
if number, numberOk = blockNrOrHash.Number(); numberOk {
@ -100,7 +100,7 @@ func (api *PrivateDebugAPIImpl) traceBlock(ctx context.Context, blockNrOrHash rp
msg, _ := txn.AsMessage(*signer, block.BaseFee(), rules)
if msg.FeeCap().IsZero() && engine != nil {
syscall := func(contract libcommon.Address, data []byte) ([]byte, error) {
syscall := func(contract common.Address, data []byte) ([]byte, error) {
return core.SysCallContract(contract, data, *chainConfig, ibs, block.Header(), engine, true /* constCall */)
}
msg.SetIsFree(engine.IsServiceTransaction(msg.From(), syscall))
@ -139,7 +139,7 @@ func (api *PrivateDebugAPIImpl) traceBlock(ctx context.Context, blockNrOrHash rp
}
// TraceTransaction implements debug_traceTransaction. Returns Geth style transaction traces.
func (api *PrivateDebugAPIImpl) TraceTransaction(ctx context.Context, hash libcommon.Hash, config *tracers.TraceConfig, stream *jsoniter.Stream) error {
func (api *PrivateDebugAPIImpl) TraceTransaction(ctx context.Context, hash common.Hash, config *tracers.TraceConfig, stream *jsoniter.Stream) error {
tx, err := api.db.BeginRo(ctx)
if err != nil {
stream.WriteNil()
@ -276,16 +276,16 @@ func (api *PrivateDebugAPIImpl) TraceCall(ctx context.Context, args ethapi.CallA
func (api *PrivateDebugAPIImpl) TraceCallMany(ctx context.Context, bundles []Bundle, simulateContext StateContext, config *tracers.TraceConfig, stream *jsoniter.Stream) error {
var (
hash libcommon.Hash
hash common.Hash
replayTransactions types.Transactions
evm *vm.EVM
blockCtx evmtypes.BlockContext
txCtx evmtypes.TxContext
overrideBlockHash map[uint64]libcommon.Hash
overrideBlockHash map[uint64]common.Hash
baseFee uint256.Int
)
overrideBlockHash = make(map[uint64]libcommon.Hash)
overrideBlockHash = make(map[uint64]common.Hash)
tx, err := api.db.BeginRo(ctx)
if err != nil {
stream.WriteNil()
@ -356,7 +356,7 @@ func (api *PrivateDebugAPIImpl) TraceCallMany(ctx context.Context, bundles []Bun
return fmt.Errorf("block %d(%x) not found", blockNum, hash)
}
getHash := func(i uint64) libcommon.Hash {
getHash := func(i uint64) common.Hash {
if hash, ok := overrideBlockHash[i]; ok {
return hash
}
@ -435,7 +435,7 @@ func (api *PrivateDebugAPIImpl) TraceCallMany(ctx context.Context, bundles []Bun
}
txCtx = core.NewEVMTxContext(msg)
ibs := evm.IntraBlockState().(*state.IntraBlockState)
ibs.Prepare(libcommon.Hash{}, parent.Hash(), txn_index)
ibs.Prepare(common.Hash{}, parent.Hash(), txn_index)
err = transactions.TraceTx(ctx, msg, blockCtx, txCtx, evm.IntraBlockState(), config, chainConfig, stream, api.evmCallTimeout)
if err != nil {

13
common/big.go
View File

@ -1,13 +0,0 @@
package common
import "math/big"
var (
Big0 = big.NewInt(0)
Big1 = big.NewInt(1)
Big2 = big.NewInt(2)
Big3 = big.NewInt(3)
Big32 = big.NewInt(32)
Big256 = big.NewInt(256)
Big257 = big.NewInt(257)
)

2
common/math/modexp.go
View File

@ -8,7 +8,7 @@ import (
"math/big"
"math/bits"
"github.com/ledgerwatch/erigon/common"
"github.com/ledgerwatch/erigon-lib/common"
)
// FastExp is semantically equivalent to x.Exp(x,y, m), but is faster for even

3
consensus/aura/auraabi/gen_block_reward.go
View File

@ -12,7 +12,6 @@ import (
ethereum "github.com/ledgerwatch/erigon"
"github.com/ledgerwatch/erigon/accounts/abi"
"github.com/ledgerwatch/erigon/accounts/abi/bind"
"github.com/ledgerwatch/erigon/common"
"github.com/ledgerwatch/erigon/core/types"
"github.com/ledgerwatch/erigon/event"
)
@ -23,7 +22,7 @@ var (
_ = strings.NewReader
_ = ethereum.NotFound
_ = bind.Bind
_ = common.Big1
_ = libcommon.Big1
_ = types.BloomLookup
_ = event.NewSubscription
)

3
consensus/aura/auraabi/gen_validator_set.go
View File

@ -12,7 +12,6 @@ import (
ethereum "github.com/ledgerwatch/erigon"
"github.com/ledgerwatch/erigon/accounts/abi"
"github.com/ledgerwatch/erigon/accounts/abi/bind"
"github.com/ledgerwatch/erigon/common"
"github.com/ledgerwatch/erigon/core/types"
"github.com/ledgerwatch/erigon/event"
)
@ -23,7 +22,7 @@ var (
_ = strings.NewReader
_ = ethereum.NotFound
_ = bind.Bind
_ = common.Big1
_ = libcommon.Big1
_ = types.BloomLookup
_ = event.NewSubscription
)

2
consensus/misc/eip1559.go
View File

@ -21,8 +21,8 @@ import (
"math/big"
"github.com/ledgerwatch/erigon-lib/chain"
"github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon/common"
"github.com/ledgerwatch/erigon/common/math"
"github.com/ledgerwatch/erigon/core/types"
"github.com/ledgerwatch/erigon/params"

2
consensus/misc/eip1559_test.go
View File

@ -21,8 +21,8 @@ import (
"testing"
"github.com/ledgerwatch/erigon-lib/chain"
"github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon/common"
"github.com/ledgerwatch/erigon/core/types"
"github.com/ledgerwatch/erigon/params"
)

5
consensus/serenity/serenity.go
View File

@ -10,7 +10,6 @@ import (
"github.com/ledgerwatch/erigon-lib/chain"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon/common"
"github.com/ledgerwatch/erigon/consensus"
"github.com/ledgerwatch/erigon/consensus/aura"
"github.com/ledgerwatch/erigon/consensus/misc"
@ -22,7 +21,7 @@ import (
// Constants for Serenity as specified into https://eips.ethereum.org/EIPS/eip-2982
var (
SerenityDifficulty = common.Big0 // Serenity block's difficulty is always 0.
SerenityDifficulty = libcommon.Big0 // Serenity block's difficulty is always 0.
SerenityNonce = types.BlockNonce{} // Serenity chain's nonces are 0.
RewardSerenity = big.NewInt(300000000000000000)
)
@ -202,7 +201,7 @@ func (s *Serenity) verifyHeader(chain consensus.ChainHeaderReader, header, paren
}
// Verify that the block number is parent's +1
if diff := new(big.Int).Sub(header.Number, parent.Number); diff.Cmp(common.Big1) != 0 {
if diff := new(big.Int).Sub(header.Number, parent.Number); diff.Cmp(libcommon.Big1) != 0 {
return consensus.ErrInvalidNumber
}

4
core/chain_makers.go
View File

@ -455,8 +455,8 @@ func MakeEmptyHeader(parent *types.Header, chainConfig *chain.Config, timestamp
header := &types.Header{
Root: parent.Root,
ParentHash: parent.Hash(),
Number: new(big.Int).Add(parent.Number, common.Big1),
Difficulty: common.Big0,
Number: new(big.Int).Add(parent.Number, libcommon.Big1),
Difficulty: libcommon.Big0,
Time: timestamp,
}

2
core/genesis.go
View File

@ -548,7 +548,7 @@ func (g *Genesis) Write(tx kv.RwTx) (*types.Block, *state.IntraBlockState, error
if err := rawdb.WriteTotalIssued(tx, 0, genesisIssuance); err != nil {
return nil, nil, err
}
return block, statedb, rawdb.WriteTotalBurnt(tx, 0, common.Big0)
return block, statedb, rawdb.WriteTotalBurnt(tx, 0, libcommon.Big0)
}
// MustCommit writes the genesis block and state to db, panicking on error.

6
core/rawdb/accessors_chain.go
View File

@ -1571,7 +1571,7 @@ func Transitioned(db kv.Getter, blockNum uint64, terminalTotalDifficulty *big.In
return false, nil
}
if terminalTotalDifficulty.Cmp(common.Big0) == 0 {
if terminalTotalDifficulty.Cmp(libcommon.Big0) == 0 {
return true, nil
}
header := ReadHeaderByNumber(db, blockNum)
@ -1579,7 +1579,7 @@ func Transitioned(db kv.Getter, blockNum uint64, terminalTotalDifficulty *big.In
return false, nil
}
if header.Difficulty.Cmp(common.Big0) == 0 {
if header.Difficulty.Cmp(libcommon.Big0) == 0 {
return true, nil
}
@ -1601,7 +1601,7 @@ func IsPosBlock(db kv.Getter, blockHash libcommon.Hash) (trans bool, err error)
return false, nil
}
return header.Difficulty.Cmp(common.Big0) == 0, nil
return header.Difficulty.Cmp(libcommon.Big0) == 0, nil
}
var SnapshotsKey = []byte("snapshots")

2
core/state/contracts/gen_changer.go
View File

@ -23,7 +23,7 @@ var (
_ = strings.NewReader
_ = ethereum.NotFound
_ = bind.Bind
_ = common.Big1
_ = libcommon.Big1
_ = types.BloomLookup
_ = event.NewSubscription
)

2
core/state/contracts/gen_phoenix.go
View File

@ -23,7 +23,7 @@ var (
_ = strings.NewReader
_ = ethereum.NotFound
_ = bind.Bind
_ = common.Big1
_ = libcommon.Big1
_ = types.BloomLookup
_ = event.NewSubscription
)

2
core/state/contracts/gen_poly.go
View File

@ -23,7 +23,7 @@ var (
_ = strings.NewReader
_ = ethereum.NotFound
_ = bind.Bind
_ = common.Big1
_ = libcommon.Big1
_ = types.BloomLookup
_ = event.NewSubscription
)

2
core/state/contracts/gen_revive.go
View File

@ -23,7 +23,7 @@ var (
_ = strings.NewReader
_ = ethereum.NotFound
_ = bind.Bind
_ = common.Big1
_ = libcommon.Big1
_ = types.BloomLookup
_ = event.NewSubscription
)

2
core/state/contracts/gen_revive2.go
View File

@ -23,7 +23,7 @@ var (
_ = strings.NewReader
_ = ethereum.NotFound
_ = bind.Bind
_ = common.Big1
_ = libcommon.Big1
_ = types.BloomLookup
_ = event.NewSubscription
)

2
core/state/contracts/gen_selfdestruct.go
View File

@ -23,7 +23,7 @@ var (
_ = strings.NewReader
_ = ethereum.NotFound
_ = bind.Bind
_ = common.Big1
_ = libcommon.Big1
_ = types.BloomLookup
_ = event.NewSubscription
)

2
core/types/block.go
View File

@ -577,7 +577,7 @@ func (h *Header) EncodeSSZ(dst []byte) (buf []byte, err error) {
// NOTE: it is skipping extra data
func (h *Header) DecodeHeaderMetadataForSSZ(buf []byte) (pos int) {
h.UncleHash = EmptyUncleHash
h.Difficulty = common.Big0
h.Difficulty = libcommon.Big0
copy(h.ParentHash[:], buf)
pos = len(h.ParentHash)

2
core/types/block_test.go
View File

@ -394,7 +394,7 @@ func TestWithdrawalsEncoding(t *testing.T) {
ParentHash: libcommon.HexToHash("0x8b00fcf1e541d371a3a1b79cc999a85cc3db5ee5637b5159646e1acd3613fd15"),
Coinbase: libcommon.HexToAddress("0x571846e42308df2dad8ed792f44a8bfddf0acb4d"),
Root: libcommon.HexToHash("0x351780124dae86b84998c6d4fe9a88acfb41b4856b4f2c56767b51a4e2f94dd4"),
Difficulty: common.Big0,
Difficulty: libcommon.Big0,
Number: big.NewInt(20_000_000),
GasLimit: 30_000_000,
GasUsed: 3_074_345,

2
core/types/transaction_test.go
View File

@ -439,7 +439,7 @@ func TestTransactionCoding(t *testing.T) {
t.Fatalf("could not generate key: %v", err)
}
var (
signer = LatestSignerForChainID(common.Big1)
signer = LatestSignerForChainID(libcommon.Big1)
addr = libcommon.HexToAddress("0x0000000000000000000000000000000000000001")
recipient = libcommon.HexToAddress("095e7baea6a6c7c4c2dfeb977efac326af552d87")
accesses = types2.AccessList{{Address: addr, StorageKeys: []libcommon.Hash{{0}}}}

2
core/vm/contracts.go
View File

@ -456,7 +456,7 @@ func (c *bigModExp) Run(input []byte) ([]byte, error) {
case mod.BitLen() == 0:
// Modulo 0 is undefined, return zero
return common.LeftPadBytes([]byte{}, int(modLen)), nil
case base.Cmp(common.Big1) == 0:
case base.Cmp(libcommon.Big1) == 0:
//If base == 1, then we can just return base % mod (if mod >= 1, which it is)
v = base.Mod(base, mod).Bytes()
//case mod.Bit(0) == 0:

3
eth/backend.go
View File

@ -75,7 +75,6 @@ import (
"github.com/ledgerwatch/erigon/cmd/sentinel/sentinel/handshake"
"github.com/ledgerwatch/erigon/cmd/sentinel/sentinel/service"
"github.com/ledgerwatch/erigon/cmd/sentry/sentry"
"github.com/ledgerwatch/erigon/common"
"github.com/ledgerwatch/erigon/common/debug"
"github.com/ledgerwatch/erigon/consensus"
"github.com/ledgerwatch/erigon/consensus/bor"
@ -191,7 +190,7 @@ func splitAddrIntoHostAndPort(addr string) (host string, port int, err error) {
// New creates a new Ethereum object (including the
// initialisation of the common Ethereum object)
func New(stack *node.Node, config *ethconfig.Config, logger log.Logger) (*Ethereum, error) {
if config.Miner.GasPrice == nil || config.Miner.GasPrice.Cmp(common.Big0) <= 0 {
if config.Miner.GasPrice == nil || config.Miner.GasPrice.Cmp(libcommon.Big0) <= 0 {
log.Warn("Sanitizing invalid miner gas price", "provided", config.Miner.GasPrice, "updated", ethconfig.Defaults.Miner.GasPrice)
config.Miner.GasPrice = new(big.Int).Set(ethconfig.Defaults.Miner.GasPrice)
}

15
eth/gasprice/feehistory.go
View File

@ -26,7 +26,6 @@ import (
"github.com/holiman/uint256"
libcommon "github.com/ledgerwatch/erigon-lib/common"
"github.com/ledgerwatch/erigon/common"
"github.com/ledgerwatch/erigon/consensus/misc"
"github.com/ledgerwatch/erigon/core/types"
"github.com/ledgerwatch/erigon/rpc"
@ -203,7 +202,7 @@ func (oracle *Oracle) resolveBlockRange(ctx context.Context, lastBlock rpc.Block
// value can be derived from the newest block.
func (oracle *Oracle) FeeHistory(ctx context.Context, blocks int, unresolvedLastBlock rpc.BlockNumber, rewardPercentiles []float64) (*big.Int, [][]*big.Int, []*big.Int, []float64, error) {
if blocks < 1 {
return common.Big0, nil, nil, nil, nil // returning with no data and no error means there are no retrievable blocks
return libcommon.Big0, nil, nil, nil, nil // returning with no data and no error means there are no retrievable blocks
}
if blocks > maxFeeHistory {
log.Warn("Sanitizing fee history length", "requested", blocks, "truncated", maxFeeHistory)
@ -211,10 +210,10 @@ func (oracle *Oracle) FeeHistory(ctx context.Context, blocks int, unresolvedLast
}
for i, p := range rewardPercentiles {
if p < 0 || p > 100 {
return common.Big0, nil, nil, nil, fmt.Errorf("%w: %f", ErrInvalidPercentile, p)
return libcommon.Big0, nil, nil, nil, fmt.Errorf("%w: %f", ErrInvalidPercentile, p)
}
if i > 0 && p < rewardPercentiles[i-1] {
return common.Big0, nil, nil, nil, fmt.Errorf("%w: #%d:%f > #%d:%f", ErrInvalidPercentile, i-1, rewardPercentiles[i-1], i, p)
return libcommon.Big0, nil, nil, nil, fmt.Errorf("%w: #%d:%f > #%d:%f", ErrInvalidPercentile, i-1, rewardPercentiles[i-1], i, p)
}
}
// Only process blocks if reward percentiles were requested
@ -229,7 +228,7 @@ func (oracle *Oracle) FeeHistory(ctx context.Context, blocks int, unresolvedLast
)
pendingBlock, pendingReceipts, lastBlock, blocks, err := oracle.resolveBlockRange(ctx, unresolvedLastBlock, blocks, maxHistory)
if err != nil || blocks == 0 {
return common.Big0, nil, nil, nil, err
return libcommon.Big0, nil, nil, nil, err
}
oldestBlock := lastBlock + 1 - uint64(blocks)
@ -244,7 +243,7 @@ func (oracle *Oracle) FeeHistory(ctx context.Context, blocks int, unresolvedLast
)
for ; blocks > 0; blocks-- {
if err = libcommon.Stopped(ctx.Done()); err != nil {
return common.Big0, nil, nil, nil, err
return libcommon.Big0, nil, nil, nil, err
}
// Retrieve the next block number to fetch with this goroutine
blockNumber := atomic.AddUint64(&next, 1) - 1
@ -273,7 +272,7 @@ func (oracle *Oracle) FeeHistory(ctx context.Context, blocks int, unresolvedLast
}
if fees.err != nil {
return common.Big0, nil, nil, nil, fees.err
return libcommon.Big0, nil, nil, nil, fees.err
}
i := int(fees.blockNumber - oldestBlock)
if fees.header != nil {
@ -286,7 +285,7 @@ func (oracle *Oracle) FeeHistory(ctx context.Context, blocks int, unresolvedLast
}
}
if firstMissing == 0 {
return common.Big0, nil, nil, nil, nil
return libcommon.Big0, nil, nil, nil, nil
}
if len(rewardPercentiles) != 0 {
reward = reward[:firstMissing]

2
eth/stagedsync/stage_headers.go
View File

@ -647,7 +647,7 @@ func saveDownloadedPoSHeaders(tx kv.RwTx, cfg HeadersCfg, headerInserter *header
return headerInserter.FeedHeaderPoS(tx, &h, h.Hash())
}
foundPow = h.Difficulty.Cmp(common.Big0) != 0
foundPow = h.Difficulty.Cmp(libcommon.Big0) != 0
if foundPow {
return headerInserter.FeedHeaderPoS(tx, &h, h.Hash())
}

7
ethdb/privateapi/engine_test.go
View File

@ -13,7 +13,6 @@ import (
"github.com/ledgerwatch/erigon-lib/kv/memdb"
"github.com/stretchr/testify/require"
"github.com/ledgerwatch/erigon/common"
"github.com/ledgerwatch/erigon/core/rawdb"
"github.com/ledgerwatch/erigon/turbo/engineapi"
"github.com/ledgerwatch/erigon/turbo/shards"
@ -96,7 +95,7 @@ func TestMockDownloadRequest(t *testing.T) {
hd := headerdownload.NewHeaderDownload(0, 0, nil, nil)
hd.SetPOSSync(true)
events := shards.NewEvents()
backend := NewEthBackendServer(ctx, nil, db, events, nil, &chain.Config{TerminalTotalDifficulty: common.Big1}, nil, hd, false)
backend := NewEthBackendServer(ctx, nil, db, events, nil, &chain.Config{TerminalTotalDifficulty: libcommon.Big1}, nil, hd, false)
var err error
var reply *remote.EnginePayloadStatus
@ -155,7 +154,7 @@ func TestMockValidExecution(t *testing.T) {
hd.SetPOSSync(true)
events := shards.NewEvents()
backend := NewEthBackendServer(ctx, nil, db, events, nil, &chain.Config{TerminalTotalDifficulty: common.Big1}, nil, hd, false)
backend := NewEthBackendServer(ctx, nil, db, events, nil, &chain.Config{TerminalTotalDifficulty: libcommon.Big1}, nil, hd, false)
var err error
var reply *remote.EnginePayloadStatus
@ -191,7 +190,7 @@ func TestMockInvalidExecution(t *testing.T) {
hd.SetPOSSync(true)
events := shards.NewEvents()
backend := NewEthBackendServer(ctx, nil, db, events, nil, &chain.Config{TerminalTotalDifficulty: common.Big1}, nil, hd, false)
backend := NewEthBackendServer(ctx, nil, db, events, nil, &chain.Config{TerminalTotalDifficulty: libcommon.Big1}, nil, hd, false)
var err error
var reply *remote.EnginePayloadStatus

3
ethstats/ethstats.go
View File

@ -37,7 +37,6 @@ import (
"github.com/ledgerwatch/log/v3"
"github.com/ledgerwatch/erigon/cmd/sentry/sentry"
"github.com/ledgerwatch/erigon/common"
"github.com/ledgerwatch/erigon/consensus"
"github.com/ledgerwatch/erigon/core/rawdb"
"github.com/ledgerwatch/erigon/core/types"
@ -537,7 +536,7 @@ func (s *Service) reportBlock(conn *connWrapper) error {
// and assembles the block stats. If block is nil, the current head is processed.
func (s *Service) assembleBlockStats(block *types.Block, td *big.Int) *blockStats {
if td == nil {
td = common.Big0
td = libcommon.Big0
}
// Gather the block infos from the local blockchain
txs := make([]txStats, 0, len(block.Transactions()))

2
go.mod
View File

@ -3,7 +3,7 @@ module github.com/ledgerwatch/erigon
go 1.18
require (
github.com/ledgerwatch/erigon-lib v0.0.0-20230126112554-7c1f7af5cac5
github.com/ledgerwatch/erigon-lib v0.0.0-20230127042956-cea02d548b14
github.com/ledgerwatch/erigon-snapshot v1.1.1-0.20230120022649-cd9409a200da
github.com/ledgerwatch/log/v3 v3.7.0
github.com/ledgerwatch/secp256k1 v1.0.0

4
go.sum
View File

@ -555,8 +555,8 @@ github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
github.com/kylelemons/godebug v0.0.0-20170224010052-a616ab194758 h1:0D5M2HQSGD3PYPwICLl+/9oulQauOuETfgFvhBDffs0=
github.com/leanovate/gopter v0.2.9 h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7c=
github.com/leanovate/gopter v0.2.9/go.mod h1:U2L/78B+KVFIx2VmW6onHJQzXtFb+p5y3y2Sh+Jxxv8=
github.com/ledgerwatch/erigon-lib v0.0.0-20230126112554-7c1f7af5cac5 h1:gjHEHoudBZiI3XnN6dUqA1qinJs/nrXUCHqHtEYJ39o=
github.com/ledgerwatch/erigon-lib v0.0.0-20230126112554-7c1f7af5cac5/go.mod h1:NDe2LVxaewSK8PNTC9GshWNz03No8whA/W69cVTWCKM=
github.com/ledgerwatch/erigon-lib v0.0.0-20230127042956-cea02d548b14 h1:+evJgKTZXDIKV2sYIzqwQhXFC4CWd5a9xZxcbqRJoWk=
github.com/ledgerwatch/erigon-lib v0.0.0-20230127042956-cea02d548b14/go.mod h1:NDe2LVxaewSK8PNTC9GshWNz03No8whA/W69cVTWCKM=
github.com/ledgerwatch/erigon-snapshot v1.1.1-0.20230120022649-cd9409a200da h1:lQQBOHzAUThkymfXJj/m07vAjyMx9XoMMy3OomaeOrA=
github.com/ledgerwatch/erigon-snapshot v1.1.1-0.20230120022649-cd9409a200da/go.mod h1:3AuPxZc85jkehh/HA9h8gabv5MSi3kb/ddtzBsTVJFo=
github.com/ledgerwatch/log/v3 v3.7.0 h1:aFPEZdwZx4jzA3+/Pf8wNDN5tCI0cIolq/kfvgcM+og=

2
tests/contracts/gen_selfDestructor.go
View File

@ -23,7 +23,7 @@ var (
_ = strings.NewReader
_ = ethereum.NotFound
_ = bind.Bind
_ = common.Big1
_ = libcommon.Big1
_ = types.BloomLookup
_ = event.NewSubscription
)

2
tests/contracts/gen_testcontract.go
View File

@ -23,7 +23,7 @@ var (
_ = strings.NewReader
_ = ethereum.NotFound
_ = bind.Bind
_ = common.Big1
_ = libcommon.Big1
_ = types.BloomLookup
_ = event.NewSubscription
)

3
turbo/stages/mock_sentry.go
View File

@ -38,7 +38,6 @@ import (
"github.com/ledgerwatch/erigon/core/types/accounts"
"github.com/ledgerwatch/erigon/cmd/sentry/sentry"
"github.com/ledgerwatch/erigon/common"
"github.com/ledgerwatch/erigon/consensus"
"github.com/ledgerwatch/erigon/consensus/ethash"
"github.com/ledgerwatch/erigon/core"
@ -520,7 +519,7 @@ func MockWithZeroTTD(t *testing.T, withPosDownloader bool) *MockSentry {
key, _ := crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
address := crypto.PubkeyToAddress(key.PublicKey)
chainConfig := params.AllProtocolChanges
chainConfig.TerminalTotalDifficulty = common.Big0
chainConfig.TerminalTotalDifficulty = libcommon.Big0
gspec := &core.Genesis{
Config: chainConfig,
Alloc: core.GenesisAlloc{

3
turbo/stages/sentry_mock_test.go
View File

@ -11,7 +11,6 @@ import (
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/ledgerwatch/erigon/common"
"github.com/ledgerwatch/erigon/common/u256"
"github.com/ledgerwatch/erigon/core"
"github.com/ledgerwatch/erigon/core/types"
@ -629,7 +628,7 @@ func TestPoSSyncWithInvalidHeader(t *testing.T) {
lastValidHeader := chain.Headers[0]
invalidParent := types.CopyHeader(chain.Headers[1])
invalidParent.Difficulty = common.Big1
invalidParent.Difficulty = libcommon.Big1
invalidTip := chain.TopBlock.Header()
invalidTip.ParentHash = invalidParent.Hash()

24
turbo/trie/trie_test.go
View File

@ -229,7 +229,7 @@ func BenchmarkHash(b *testing.B) {
for i := 0; i < len(accounts); i++ {
var (
nonce = uint64(random.Int63())
balance = new(big.Int).Rand(random, new(big.Int).Exp(common.Big2, common.Big256, nil))
balance = new(big.Int).Rand(random, new(big.Int).Exp(libcommon.Big2, libcommon.Big256, nil))
root = EmptyRoot
code = crypto.Keccak256(nil)
)
@ -312,7 +312,7 @@ func TestCodeNodeValid(t *testing.T) {
for i := 0; i < len(addresses); i++ {
codeValues[i] = genRandomByteArrayOfLen(128)
codeHash := libcommon.BytesToHash(crypto.Keccak256(codeValues[i]))
balance := new(big.Int).Rand(random, new(big.Int).Exp(common.Big2, common.Big256, nil))
balance := new(big.Int).Rand(random, new(big.Int).Exp(libcommon.Big2, libcommon.Big256, nil))
acc := accounts.NewAccount()
acc.Nonce = uint64(random.Int63())
acc.Balance.SetFromBig(balance)
@ -340,7 +340,7 @@ func TestCodeNodeUpdateNotExisting(t *testing.T) {
codeValue := genRandomByteArrayOfLen(128)
codeHash := libcommon.BytesToHash(crypto.Keccak256(codeValue))
balance := new(big.Int).Rand(random, new(big.Int).Exp(common.Big2, common.Big256, nil))
balance := new(big.Int).Rand(random, new(big.Int).Exp(libcommon.Big2, libcommon.Big256, nil))
acc := accounts.NewAccount()
acc.Nonce = uint64(random.Int63())
@ -368,7 +368,7 @@ func TestCodeNodeGetNotExistingAccount(t *testing.T) {
codeValue := genRandomByteArrayOfLen(128)
codeHash := libcommon.BytesToHash(crypto.Keccak256(codeValue))
balance := new(big.Int).Rand(random, new(big.Int).Exp(common.Big2, common.Big256, nil))
balance := new(big.Int).Rand(random, new(big.Int).Exp(libcommon.Big2, libcommon.Big256, nil))
acc := accounts.NewAccount()
acc.Nonce = uint64(random.Int63())
@ -413,7 +413,7 @@ func TestCodeNodeGetExistingAccountNoCodeNotEmpty(t *testing.T) {
codeValue := genRandomByteArrayOfLen(128)
codeHash := libcommon.BytesToHash(crypto.Keccak256(codeValue))
balance := new(big.Int).Rand(random, new(big.Int).Exp(common.Big2, common.Big256, nil))
balance := new(big.Int).Rand(random, new(big.Int).Exp(libcommon.Big2, libcommon.Big256, nil))
acc := accounts.NewAccount()
acc.Nonce = uint64(random.Int63())
@ -436,7 +436,7 @@ func TestCodeNodeGetExistingAccountEmptyCode(t *testing.T) {
address := getAddressForIndex(0)
codeHash := EmptyCodeHash
balance := new(big.Int).Rand(random, new(big.Int).Exp(common.Big2, common.Big256, nil))
balance := new(big.Int).Rand(random, new(big.Int).Exp(libcommon.Big2, libcommon.Big256, nil))
acc := accounts.NewAccount()
acc.Nonce = uint64(random.Int63())
@ -461,7 +461,7 @@ func TestCodeNodeWrongHash(t *testing.T) {
codeValue1 := genRandomByteArrayOfLen(128)
codeHash1 := libcommon.BytesToHash(crypto.Keccak256(codeValue1))
balance := new(big.Int).Rand(random, new(big.Int).Exp(common.Big2, common.Big256, nil))
balance := new(big.Int).Rand(random, new(big.Int).Exp(libcommon.Big2, libcommon.Big256, nil))
acc := accounts.NewAccount()
acc.Nonce = uint64(random.Int63())
@ -486,7 +486,7 @@ func TestCodeNodeUpdateAccountAndCodeValidHash(t *testing.T) {
codeValue1 := genRandomByteArrayOfLen(128)
codeHash1 := libcommon.BytesToHash(crypto.Keccak256(codeValue1))
balance := new(big.Int).Rand(random, new(big.Int).Exp(common.Big2, common.Big256, nil))
balance := new(big.Int).Rand(random, new(big.Int).Exp(libcommon.Big2, libcommon.Big256, nil))
acc := accounts.NewAccount()
acc.Nonce = uint64(random.Int63())
@ -518,7 +518,7 @@ func TestCodeNodeUpdateAccountAndCodeInvalidHash(t *testing.T) {
codeValue1 := genRandomByteArrayOfLen(128)
codeHash1 := libcommon.BytesToHash(crypto.Keccak256(codeValue1))
balance := new(big.Int).Rand(random, new(big.Int).Exp(common.Big2, common.Big256, nil))
balance := new(big.Int).Rand(random, new(big.Int).Exp(libcommon.Big2, libcommon.Big256, nil))
acc := accounts.NewAccount()
acc.Nonce = uint64(random.Int63())
@ -552,7 +552,7 @@ func TestCodeNodeUpdateAccountChangeCodeHash(t *testing.T) {
codeValue1 := genRandomByteArrayOfLen(128)
codeHash1 := libcommon.BytesToHash(crypto.Keccak256(codeValue1))
balance := new(big.Int).Rand(random, new(big.Int).Exp(common.Big2, common.Big256, nil))
balance := new(big.Int).Rand(random, new(big.Int).Exp(libcommon.Big2, libcommon.Big256, nil))
acc := accounts.NewAccount()
acc.Nonce = uint64(random.Int63())
@ -585,7 +585,7 @@ func TestCodeNodeUpdateAccountNoChangeCodeHash(t *testing.T) {
codeValue1 := genRandomByteArrayOfLen(128)
codeHash1 := libcommon.BytesToHash(crypto.Keccak256(codeValue1))
balance := new(big.Int).Rand(random, new(big.Int).Exp(common.Big2, common.Big256, nil))
balance := new(big.Int).Rand(random, new(big.Int).Exp(libcommon.Big2, libcommon.Big256, nil))
acc := accounts.NewAccount()
acc.Nonce = uint64(random.Int63())
@ -598,7 +598,7 @@ func TestCodeNodeUpdateAccountNoChangeCodeHash(t *testing.T) {
assert.Nil(t, err, "should successfully insert code")
acc.Nonce = uint64(random.Int63())
balance = new(big.Int).Rand(random, new(big.Int).Exp(common.Big2, common.Big256, nil))
balance = new(big.Int).Rand(random, new(big.Int).Exp(libcommon.Big2, libcommon.Big256, nil))
acc.Balance.SetFromBig(balance)
trie.UpdateAccount(crypto.Keccak256(address[:]), &acc)