forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-07-26 06:36:43 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

fix build

Browse source
This commit is contained in:
Arpit Temani 2023-08-21 17:48:09 +05:30
parent 27907a59ab
commit d3c5bc9b45
149 changed files with 1673 additions and 4340 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

51
accounts/abi/bind/backends/simulated.go
View file

@ -99,7 +99,6 @@ func NewSimulatedBackendWithDatabase(database ethdb.Database, alloc core.Genesis
block := backend.blockchain.GetBlock(header.Hash(), header.Number.Uint64())
backend.rollback(block)
return backend
}
@ -125,7 +124,6 @@ func (b *SimulatedBackend) Commit() common.Hash {
if _, err := b.blockchain.InsertChain([]*types.Block{b.pendingBlock}); err != nil {
panic(err) // This cannot happen unless the simulator is wrong, fail in that case
}
blockHash := b.pendingBlock.Hash()
// Using the last inserted block here makes it possible to build on a side
@ -172,14 +170,11 @@ func (b *SimulatedBackend) Fork(ctx context.Context, parent common.Hash) error {
if len(b.pendingBlock.Transactions()) != 0 {
return errors.New("pending block dirty")
}
block, err := b.blockByHash(ctx, parent)
if err != nil {
return err
}
b.rollback(block)
return nil
}
@ -188,12 +183,10 @@ func (b *SimulatedBackend) stateByBlockNumber(ctx context.Context, blockNumber *
if blockNumber == nil || blockNumber.Cmp(b.blockchain.CurrentBlock().Number) == 0 {
return b.blockchain.State()
}
block, err := b.blockByNumber(ctx, blockNumber)
if err != nil {
return nil, err
}
return b.blockchain.StateAt(block.Root())
}
@ -247,7 +240,6 @@ func (b *SimulatedBackend) StorageAt(ctx context.Context, contract common.Addres
}
val := stateDB.GetState(contract, key)
return val[:], nil
}
@ -260,7 +252,6 @@ func (b *SimulatedBackend) TransactionReceipt(ctx context.Context, txHash common
if receipt == nil {
return nil, ethereum.NotFound
}
return receipt, nil
}
@ -276,12 +267,10 @@ func (b *SimulatedBackend) TransactionByHash(ctx context.Context, txHash common.
if tx != nil {
return tx, true, nil
}
tx, _, _, _ = rawdb.ReadTransaction(b.database, txHash)
if tx != nil {
return tx, false, nil
}
return nil, false, ethereum.NotFound
}
@ -416,11 +405,9 @@ func (b *SimulatedBackend) PendingCodeAt(ctx context.Context, contract common.Ad
func newRevertError(result *core.ExecutionResult) *revertError {
reason, errUnpack := abi.UnpackRevert(result.Revert())
err := errors.New("execution reverted")
if errUnpack == nil {
err = fmt.Errorf("execution reverted: %v", reason)
}
return &revertError{
error: err,
reason: hexutil.Encode(result.Revert()),
@ -453,12 +440,10 @@ func (b *SimulatedBackend) CallContract(ctx context.Context, call ethereum.CallM
if blockNumber != nil && blockNumber.Cmp(b.blockchain.CurrentBlock().Number) != 0 {
return nil, errBlockNumberUnsupported
}
stateDB, err := b.blockchain.State()
if err != nil {
return nil, err
}
res, err := b.callContract(ctx, call, b.blockchain.CurrentBlock(), stateDB)
if err != nil {
return nil, err
@ -467,7 +452,6 @@ func (b *SimulatedBackend) CallContract(ctx context.Context, call ethereum.CallM
if len(res.Revert()) > 0 {
return nil, newRevertError(res)
}
return res.Return(), res.Err
}
@ -485,7 +469,6 @@ func (b *SimulatedBackend) PendingCallContract(ctx context.Context, call ethereu
if len(res.Revert()) > 0 {
return nil, newRevertError(res)
}
return res.Return(), res.Err
}
@ -507,7 +490,6 @@ func (b *SimulatedBackend) SuggestGasPrice(ctx context.Context) (*big.Int, error
if b.pendingBlock.Header().BaseFee != nil {
return b.pendingBlock.Header().BaseFee, nil
}
return big.NewInt(1), nil
}
@ -529,7 +511,6 @@ func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMs
hi uint64
cap uint64
)
if call.Gas >= params.TxGas {
hi = call.Gas
} else {
@ -537,7 +518,6 @@ func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMs
}
// Normalize the max fee per gas the call is willing to spend.
var feeCap *big.Int
if call.GasPrice != nil && (call.GasFeeCap != nil || call.GasTipCap != nil) {
return 0, errors.New("both gasPrice and (maxFeePerGas or maxPriorityFeePerGas) specified")
} else if call.GasPrice != nil {
@ -550,30 +530,24 @@ func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMs
// Recap the highest gas allowance with account's balance.
if feeCap.BitLen() != 0 {
balance := b.pendingState.GetBalance(call.From) // from can't be nil
available := new(big.Int).Set(balance)
if call.Value != nil {
if call.Value.Cmp(available) >= 0 {
return 0, core.ErrInsufficientFundsForTransfer
}
available.Sub(available, call.Value)
}
allowance := new(big.Int).Div(available, feeCap)
if allowance.IsUint64() && hi > allowance.Uint64() {
transfer := call.Value
if transfer == nil {
transfer = new(big.Int)
}
log.Warn("Gas estimation capped by limited funds", "original", hi, "balance", balance,
"sent", transfer, "feecap", feeCap, "fundable", allowance)
hi = allowance.Uint64()
}
}
cap = hi
// Create a helper to check if a gas allowance results in an executable transaction
@ -588,10 +562,8 @@ func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMs
if errors.Is(err, core.ErrIntrinsicGas) {
return true, nil, nil // Special case, raise gas limit
}
return true, nil, err // Bail out
}
return res.Failed(), res, nil
}
// Execute the binary search and hone in on an executable gas limit
@ -605,7 +577,6 @@ func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMs
if err != nil {
return 0, err
}
if failed {
lo = mid
} else {
@ -618,38 +589,33 @@ func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMs
if err != nil {
return 0, err
}
if failed {
if result != nil && result.Err != vm.ErrOutOfGas {
if len(result.Revert()) > 0 {
return 0, newRevertError(result)
}
return 0, result.Err
}
// Otherwise, the specified gas cap is too low
return 0, fmt.Errorf("gas required exceeds allowance (%d)", cap)
}
}
return hi, nil
}
// callContract implements common code between normal and pending contract calls.
// state is modified during execution, make sure to copy it if necessary.
func (b *SimulatedBackend) callContract(_ context.Context, call ethereum.CallMsg, header *types.Header, stateDB *state.StateDB) (*core.ExecutionResult, error) {
func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallMsg, header *types.Header, stateDB *state.StateDB) (*core.ExecutionResult, error) {
// Gas prices post 1559 need to be initialized
if call.GasPrice != nil && (call.GasFeeCap != nil || call.GasTipCap != nil) {
return nil, errors.New("both gasPrice and (maxFeePerGas or maxPriorityFeePerGas) specified")
}
head := b.blockchain.CurrentHeader()
if !b.blockchain.Config().IsLondon(head.Number) {
// If there's no basefee, then it must be a non-1559 execution
if call.GasPrice == nil {
call.GasPrice = new(big.Int)
}
call.GasFeeCap, call.GasTipCap = call.GasPrice, call.GasPrice
} else {
// A basefee is provided, necessitating 1559-type execution
@ -661,7 +627,6 @@ func (b *SimulatedBackend) callContract(_ context.Context, call ethereum.CallMsg
if call.GasFeeCap == nil {
call.GasFeeCap = new(big.Int)
}
if call.GasTipCap == nil {
call.GasTipCap = new(big.Int)
}
@ -676,7 +641,6 @@ func (b *SimulatedBackend) callContract(_ context.Context, call ethereum.CallMsg
if call.Gas == 0 {
call.Gas = 50000000
}
if call.Value == nil {
call.Value = new(big.Int)
}
@ -706,7 +670,6 @@ func (b *SimulatedBackend) callContract(_ context.Context, call ethereum.CallMsg
vmEnv := vm.NewEVM(evmContext, txContext, stateDB, b.config, vm.Config{NoBaseFee: true})
gasPool := new(core.GasPool).AddGas(math.MaxUint64)
//nolint:contextcheck
return core.ApplyMessage(vmEnv, msg, gasPool, context.Background())
}
@ -726,18 +689,15 @@ func (b *SimulatedBackend) SendTransaction(ctx context.Context, tx *types.Transa
if err != nil {
return fmt.Errorf("invalid transaction: %v", err)
}
nonce := b.pendingState.GetNonce(sender)
if tx.Nonce() != nonce {
return fmt.Errorf("invalid transaction nonce: got %d, want %d", tx.Nonce(), nonce)
}
// Include tx in chain
// nolint : contextcheck
blocks, receipts := core.GenerateChain(b.config, block, ethash.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) {
for _, tx := range b.pendingBlock.Transactions() {
block.AddTxWithChain(b.blockchain, tx)
}
block.AddTxWithChain(b.blockchain, tx)
})
stateDB, _ := b.blockchain.State()
@ -745,7 +705,6 @@ func (b *SimulatedBackend) SendTransaction(ctx context.Context, tx *types.Transa
b.pendingBlock = blocks[0]
b.pendingState, _ = state.New(b.pendingBlock.Root(), stateDB.Database(), nil)
b.pendingReceipts = receipts[0]
return nil
}
@ -764,7 +723,6 @@ func (b *SimulatedBackend) FilterLogs(ctx context.Context, query ethereum.Filter
if query.FromBlock != nil {
from = query.FromBlock.Int64()
}
to := int64(-1)
if query.ToBlock != nil {
to = query.ToBlock.Int64()
@ -777,12 +735,10 @@ func (b *SimulatedBackend) FilterLogs(ctx context.Context, query ethereum.Filter
if err != nil {
return nil, err
}
res := make([]types.Log, len(logs))
for i, nLog := range logs {
res[i] = *nLog
}
return res, nil
}
@ -799,7 +755,6 @@ func (b *SimulatedBackend) SubscribeFilterLogs(ctx context.Context, query ethere
// Since we're getting logs in batches, we need to flatten them into a plain stream
return event.NewSubscription(func(quit <-chan struct{}) error {
defer sub.Unsubscribe()
for {
select {
case logs := <-sink:
@ -829,7 +784,6 @@ func (b *SimulatedBackend) SubscribeNewHead(ctx context.Context, ch chan<- *type
return event.NewSubscription(func(quit <-chan struct{}) error {
defer sub.Unsubscribe()
for {
select {
case head := <-sink:
@ -893,13 +847,11 @@ func (fb *filterBackend) ChainDb() ethdb.Database { return fb.db }
func (fb *filterBackend) EventMux() *event.TypeMux { panic("not supported") }
func (fb *filterBackend) HeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Header, error) {
// nolint : exhaustive
switch number {
case rpc.PendingBlockNumber:
if block := fb.backend.pendingBlock; block != nil {
return block.Header(), nil
}
return nil, nil
case rpc.LatestBlockNumber:
return fb.bc.CurrentHeader(), nil
@ -920,7 +872,6 @@ func (fb *filterBackend) GetBody(ctx context.Context, hash common.Hash, number r
if body := fb.bc.GetBody(hash); body != nil {
return body, nil
}
return nil, errors.New("block body not found")
}

8
cmd/evm/internal/t8ntool/gen_stenv.go
View file

@ -55,13 +55,9 @@ func (s stEnv) MarshalJSON() ([]byte, error) {
enc.Withdrawals = s.Withdrawals
enc.BaseFee = (*math.HexOrDecimal256)(s.BaseFee)
enc.ParentUncleHash = s.ParentUncleHash
<<<<<<< HEAD
=======
enc.ExcessBlobGas = (*math.HexOrDecimal64)(s.ExcessBlobGas)
enc.ParentExcessBlobGas = (*math.HexOrDecimal64)(s.ParentExcessBlobGas)
enc.ParentBlobGasUsed = (*math.HexOrDecimal64)(s.ParentBlobGasUsed)
>>>>>>> bed84606583893fdb698cc1b5058cc47b4dbd837
return json.Marshal(&enc)
}
@ -163,9 +159,6 @@ func (s *stEnv) UnmarshalJSON(input []byte) error {
if dec.ParentUncleHash != nil {
s.ParentUncleHash = *dec.ParentUncleHash
}
<<<<<<< HEAD
=======
if dec.ExcessBlobGas != nil {
s.ExcessBlobGas = (*uint64)(dec.ExcessBlobGas)
}
@ -175,6 +168,5 @@ func (s *stEnv) UnmarshalJSON(input []byte) error {
if dec.ParentBlobGasUsed != nil {
s.ParentBlobGasUsed = (*uint64)(dec.ParentBlobGasUsed)
}
>>>>>>> bed84606583893fdb698cc1b5058cc47b4dbd837
return nil
}

5
cmd/evm/internal/t8ntool/transaction.go
View file

@ -122,12 +122,7 @@ func Transaction(ctx *cli.Context) error {
return NewError(ErrorIO, errors.New("only rlp supported"))
}
}
<<<<<<< HEAD
signer := types.MakeSigner(chainConfig, new(big.Int))
=======
signer := types.MakeSigner(chainConfig, new(big.Int), 0)
>>>>>>> bed84606583893fdb698cc1b5058cc47b4dbd837
// We now have the transactions in 'body', which is supposed to be an
// rlp list of transactions
it, err := rlp.NewListIterator([]byte(body))

5
cmd/evm/internal/t8ntool/transition.go
View file

@ -285,12 +285,7 @@ func Transition(ctx *cli.Context) error {
return NewError(ErrorConfig, errors.New("EIP-1559 config but missing 'currentBaseFee' in env section"))
}
}
<<<<<<< HEAD
// TODO marcello double check
if chainConfig.IsShanghai(prestate.Env.Number) && prestate.Env.Withdrawals == nil {
=======
if chainConfig.IsShanghai(big.NewInt(int64(prestate.Env.Number)), prestate.Env.Timestamp) && prestate.Env.Withdrawals == nil {
>>>>>>> bed84606583893fdb698cc1b5058cc47b4dbd837
return NewError(ErrorConfig, errors.New("Shanghai config but missing 'withdrawals' in env section"))
}

5
cmd/utils/bor_flags.go
View file

@ -118,10 +118,7 @@ func CreateBorEthereum(cfg *ethconfig.Config) *eth.Ethereum {
Fatalf("Failed to start stack: %v", err)
}
_, err = stack.Attach()
if err != nil {
Fatalf("Failed to attach to node: %v", err)
}
stack.Attach()
return ethereum
}

6
cmd/utils/flags.go
View file

@ -2001,16 +2001,13 @@ func RegisterEthService(stack *node.Node, cfg *ethconfig.Config) (ethapi.Backend
if err != nil {
Fatalf("Failed to register the Ethereum service: %v", err)
}
stack.RegisterAPIs(tracers.APIs(backend.ApiBackend))
return backend.ApiBackend, nil
}
backend, err := eth.New(stack, cfg)
if err != nil {
Fatalf("Failed to register the Ethereum service: %v", err)
}
if cfg.LightServ > 0 {
_, err := les.NewLesServer(stack, backend, cfg)
if err != nil {
@ -2018,7 +2015,6 @@ func RegisterEthService(stack *node.Node, cfg *ethconfig.Config) (ethapi.Backend
}
}
stack.RegisterAPIs(tracers.APIs(backend.APIBackend))
return backend.APIBackend, backend
}
@ -2267,7 +2263,7 @@ func MakeChain(ctx *cli.Context, stack *node.Node, readonly bool) (*core.BlockCh
UseHeimdallApp: ctx.Bool(UseHeimdallAppFlag.Name),
}
_ = CreateBorEthereum(configs)
engine := ethconfig.CreateConsensusEngine(stack, config, configs, &ethashConfig, cliqueConfig, nil, false, chainDb, nil)
engine := ethconfig.CreateConsensusEngine(stack, config, configs, nil, false, chainDb, nil)
if gcmode := ctx.String(GCModeFlag.Name); gcmode != "full" && gcmode != "archive" {
Fatalf("--%s must be either 'full' or 'archive'", GCModeFlag.Name)

4
consensus/bor/api/caller.go
View file

@ -11,6 +11,6 @@ import (
//go:generate mockgen -destination=./caller_mock.go -package=api . Caller
type Caller interface {
Call(ctx context.Context, args ethapi.TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, overrides *ethapi.StateOverride) (hexutil.Bytes, error)
CallWithState(ctx context.Context, args ethapi.TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, state *state.StateDB, overrides *ethapi.StateOverride) (hexutil.Bytes, error)
Call(ctx context.Context, args ethapi.TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, overrides *ethapi.StateOverride, blockOverrides *ethapi.BlockOverrides) (hexutil.Bytes, error)
CallWithState(ctx context.Context, args ethapi.TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, state *state.StateDB, overrides *ethapi.StateOverride, blockOverrides *ethapi.BlockOverrides) (hexutil.Bytes, error)
}

7
consensus/bor/bor.go
View file

@ -30,6 +30,7 @@ import (
"github.com/ethereum/go-ethereum/consensus/bor/statefull"
"github.com/ethereum/go-ethereum/consensus/bor/valset"
"github.com/ethereum/go-ethereum/consensus/misc"
"github.com/ethereum/go-ethereum/consensus/misc/eip1559"
"github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/core/state"
"github.com/ethereum/go-ethereum/core/types"
@ -294,7 +295,7 @@ func (c *Bor) Author(header *types.Header) (common.Address, error) {
}
// VerifyHeader checks whether a header conforms to the consensus rules.
func (c *Bor) VerifyHeader(chain consensus.ChainHeaderReader, header *types.Header, _ bool) error {
func (c *Bor) VerifyHeader(chain consensus.ChainHeaderReader, header *types.Header) error {
return c.verifyHeader(chain, header, nil)
}
@ -309,7 +310,7 @@ func (c *Bor) SetSpanner(spanner Spanner) {
// VerifyHeaders is similar to VerifyHeader, but verifies a batch of headers. The
// method returns a quit channel to abort the operations and a results channel to
// retrieve the async verifications (the order is that of the input slice).
func (c *Bor) VerifyHeaders(chain consensus.ChainHeaderReader, headers []*types.Header, _ []bool) (chan<- struct{}, <-chan error) {
func (c *Bor) VerifyHeaders(chain consensus.ChainHeaderReader, headers []*types.Header) (chan<- struct{}, <-chan error) {
abort := make(chan struct{})
results := make(chan error, len(headers))
@ -443,7 +444,7 @@ func (c *Bor) verifyCascadingFields(chain consensus.ChainHeaderReader, header *t
if err := misc.VerifyGaslimit(parent.GasLimit, header.GasLimit); err != nil {
return err
}
} else if err := misc.VerifyEip1559Header(chain.Config(), parent, header); err != nil {
} else if err := eip1559.VerifyEIP1559Header(chain.Config(), parent, header); err != nil {
// Verify the header's EIP-1559 attributes.
return err
}

2
consensus/bor/bor_test.go
View file

@ -71,7 +71,7 @@ func TestGenesisContractChange(t *testing.T) {
b.Finalize(chain, h, statedb, nil, nil, nil)
// write state to database
root, err := statedb.Commit(false)
root, err := statedb.Commit(0, false)
require.NoError(t, err)
require.NoError(t, statedb.Database().TrieDB().Commit(root, true))

2
consensus/bor/contract/client.go
View file

@ -122,7 +122,7 @@ func (gc *GenesisContractsClient) LastStateId(state *state.StateDB, number uint6
Gas: &gas,
To: &toAddress,
Data: &msgData,
}, rpc.BlockNumberOrHash{BlockNumber: &blockNr, BlockHash: &hash}, state, nil)
}, rpc.BlockNumberOrHash{BlockNumber: &blockNr, BlockHash: &hash}, state, nil, nil)
if err != nil {
return nil, err
}

4
consensus/bor/heimdall/span/spanner.go
View file

@ -62,7 +62,7 @@ func (c *ChainSpanner) GetCurrentSpan(ctx context.Context, headerHash common.Has
Gas: &gas,
To: &toAddress,
Data: &msgData,
}, blockNr, nil)
}, blockNr, nil, nil)
if err != nil {
return nil, err
}
@ -111,7 +111,7 @@ func (c *ChainSpanner) GetCurrentValidatorsByBlockNrOrHash(ctx context.Context,
Gas: &gas,
To: &toAddress,
Data: &msgData,
}, blockNrOrHash, nil)
}, blockNrOrHash, nil, nil)
if err != nil {
return nil, err
}

3
consensus/ethash/ethash.go
View file

@ -18,6 +18,7 @@
package ethash
import (
"context"
"time"
"github.com/ethereum/go-ethereum/consensus"
@ -80,6 +81,6 @@ func (ethash *Ethash) APIs(chain consensus.ChainHeaderReader) []rpc.API {
// Seal generates a new sealing request for the given input block and pushes
// the result into the given channel. For the ethash engine, this method will
// just panic as sealing is not supported anymore.
func (ethash *Ethash) Seal(chain consensus.ChainHeaderReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error {
func (ethash *Ethash) Seal(ctx context.Context, chain consensus.ChainHeaderReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error {
panic("ethash (pow) sealing not supported any more")
}

5
core/blockchain.go
View file

@ -490,7 +490,6 @@ func NewParallelBlockChain(db ethdb.Database, cacheConfig *CacheConfig, genesis
// Open trie database with provided config
triedb := trie.NewDatabaseWithConfig(db, &trie.Config{
Cache: cacheConfig.TrieCleanLimit,
Journal: cacheConfig.TrieCleanJournal,
Preimages: cacheConfig.Preimages,
})
chainConfig, _, genesisErr := SetupGenesisBlockWithOverride(db, triedb, genesis, overrides)
@ -3103,3 +3102,7 @@ func (bc *BlockChain) SetTrieFlushInterval(interval time.Duration) {
func (bc *BlockChain) GetTrieFlushInterval() time.Duration {
return time.Duration(bc.flushInterval.Load())
}
func (bc *BlockChain) SubscribeChain2HeadEvent(ch chan<- Chain2HeadEvent) event.Subscription {
return bc.scope.Track(bc.chain2HeadFeed.Subscribe(ch))
}

2
core/blockchain_test.go
View file

@ -1041,7 +1041,7 @@ func TestLightVsFastVsFullChainHeads(t *testing.T) {
// Import the chain as a light node and ensure all pointers are updated
lightDb := makeDb()
defer lightDb.Close()
light, _ := NewBlockChain(lightDb, nil, gspec, nil, ethash.NewFaker(), vm.Config{}, nil, nil)
light, _ := NewBlockChain(lightDb, nil, gspec, nil, ethash.NewFaker(), vm.Config{}, nil, nil, nil)
if n, err := light.InsertHeaderChain(headers); err != nil {
t.Fatalf("failed to insert header %d: %v", n, err)
}

13
core/genesis.go
View file

@ -481,8 +481,6 @@ func (g *Genesis) configOrDefault(ghash common.Hash) *params.ChainConfig {
return params.MumbaiChainConfig
case ghash == params.BorMainnetGenesisHash:
return params.BorMainnetChainConfig
case ghash == params.KilnGenesisHash:
return DefaultKilnGenesisBlock().Config
default:
return params.AllEthashProtocolChanges
}
@ -673,17 +671,6 @@ func DefaultBorMainnetGenesisBlock() *Genesis {
}
}
func DefaultKilnGenesisBlock() *Genesis {
g := new(Genesis)
reader := strings.NewReader(KilnAllocData)
if err := json.NewDecoder(reader).Decode(g); err != nil {
panic(err)
}
return g
}
// DeveloperGenesisBlock returns the 'geth --dev' genesis block.
func DeveloperGenesisBlock(gasLimit uint64, faucet common.Address) *Genesis {
// Override the default period to the user requested one

2
core/parallel_state_processor.go
View file

@ -296,7 +296,7 @@ func (p *ParallelStateProcessor) Process(block *types.Block, statedb *state.Stat
// Iterate over and process the individual transactions
for i, tx := range block.Transactions() {
msg, err := TransactionToMessage(tx, types.MakeSigner(p.config, header.Number), header.BaseFee)
msg, err := TransactionToMessage(tx, types.MakeSigner(p.config, header.Number, header.Time), header.BaseFee)
if err != nil {
log.Error("error creating message", "err", err)
return nil, nil, 0, fmt.Errorf("could not apply tx %d [%v]: %w", i, tx.Hash().Hex(), err)

26
core/rawdb/accessors_chain.go
View file

@ -816,17 +816,9 @@ func ReadLogs(db ethdb.Reader, hash common.Hash, number uint64, config *params.C
if len(data) == 0 {
return nil
}
receipts := []*receiptLogs{}
if err := rlp.DecodeBytes(data, &receipts); err != nil {
// Receipts might be in the legacy format, try decoding that.
// TODO: to be removed after users migrated
if logs := readLegacyLogs(db, hash, number, config); logs != nil {
return logs
}
log.Error("Invalid receipt array RLP", "hash", hash, "err", err)
return nil
}
@ -834,24 +826,6 @@ func ReadLogs(db ethdb.Reader, hash common.Hash, number uint64, config *params.C
for i, receipt := range receipts {
logs[i] = receipt.Logs
}
return logs
}
// readLegacyLogs is a temporary workaround for when trying to read logs
// from a block which has its receipt stored in the legacy format. It'll
// be removed after users have migrated their freezer databases.
func readLegacyLogs(db ethdb.Reader, hash common.Hash, number uint64, config *params.ChainConfig) [][]*types.Log {
receipts := ReadReceipts(db, hash, number, config)
if receipts == nil {
return nil
}
logs := make([][]*types.Log, len(receipts))
for i, receipt := range receipts {
logs[i] = receipt.Logs
}
return logs
}

13
core/state/iterator_test.go
View file

@ -28,7 +28,7 @@ import (
func TestNodeIteratorCoverage(t *testing.T) {
// Create some arbitrary test state to iterate
db, sdb, root, _ := makeTestState()
_ = sdb.TrieDB().Commit(root, false)
sdb.TrieDB().Commit(root, false)
state, err := New(root, sdb, nil)
if err != nil {
@ -46,15 +46,12 @@ func TestNodeIteratorCoverage(t *testing.T) {
seenNodes = make(map[common.Hash]struct{})
seenCodes = make(map[common.Hash]struct{})
)
it := db.NewIterator(nil, nil)
for it.Next() {
ok, hash := isTrieNode(sdb.TrieDB().Scheme(), it.Key(), it.Value())
if !ok {
continue
}
seenNodes[hash] = struct{}{}
}
it.Release()
@ -66,22 +63,19 @@ func TestNodeIteratorCoverage(t *testing.T) {
if !ok {
continue
}
if _, ok := hashes[common.BytesToHash(hash)]; !ok {
t.Errorf("state entry not reported %x", it.Key())
}
seenCodes[common.BytesToHash(hash)] = struct{}{}
}
it.Release()
// Cross-check the iterated hashes and the database/nodepool content
// Cross check the iterated hashes and the database/nodepool content
for hash := range hashes {
_, ok := seenNodes[hash]
if !ok {
_, ok = seenCodes[hash]
}
if !ok {
t.Errorf("failed to retrieve reported node %x", hash)
}
@ -90,7 +84,7 @@ func TestNodeIteratorCoverage(t *testing.T) {
// isTrieNode is a helper function which reports if the provided
// database entry belongs to a trie node or not.
func isTrieNode(scheme string, key, _ []byte) (bool, common.Hash) {
func isTrieNode(scheme string, key, val []byte) (bool, common.Hash) {
if scheme == rawdb.HashScheme {
if rawdb.IsLegacyTrieNode(key, val) {
return true, common.BytesToHash(key)
@ -105,6 +99,5 @@ func isTrieNode(scheme string, key, _ []byte) (bool, common.Hash) {
return true, crypto.Keccak256Hash(val)
}
}
return false, common.Hash{}
}

55
core/state/statedb.go
View file

@ -398,10 +398,11 @@ func (s *StateDB) ApplyMVWriteSet(writes []blockstm.WriteDescriptor) {
s.SetNonce(addr, sr.GetNonce(addr))
case CodePath:
s.SetCode(addr, sr.GetCode(addr))
// TODO - Arpit -----------------
case SuicidePath:
stateObject := sr.getDeletedStateObject(addr)
if stateObject != nil && stateObject.deleted {
s.Suicide(addr)
s.SelfDestruct(addr)
}
default:
panic(fmt.Errorf("unknown key type: %d", path.GetSubpath()))
@ -626,18 +627,11 @@ func (s *StateDB) Version() blockstm.Version {
}
}
func (s *StateDB) GetCode(addr common.Address) []byte {
stateObject := s.getStateObject(addr)
if stateObject != nil {
return stateObject.Code()
}
}
func (s *StateDB) GetCode(addr common.Address) []byte {
return MVRead(s, blockstm.NewSubpathKey(addr, CodePath), nil, func(s *StateDB) []byte {
stateObject := s.getStateObject(addr)
if stateObject != nil {
return stateObject.Code(s.db)
return stateObject.Code()
}
return nil
@ -870,12 +864,9 @@ func (s *StateDB) SelfDestruct(addr common.Address) {
})
stateObject.markSelfdestructed()
stateObject.data.Balance = new(big.Int)
}
MVWrite(s, blockstm.NewSubpathKey(addr, SuicidePath))
MVWrite(s, blockstm.NewSubpathKey(addr, BalancePath))
return true
}
func (s *StateDB) Selfdestruct6780(addr common.Address) {
@ -1038,27 +1029,27 @@ func (s *StateDB) getDeletedStateObject(addr common.Address) *stateObject {
return nil
}
}
}
// If snapshot unavailable or reading from it failed, load from the database
if data == nil {
start := time.Now()
var err error
data, err = s.trie.GetAccount(addr)
if metrics.EnabledExpensive {
s.AccountReads += time.Since(start)
}
if err != nil {
s.setError(fmt.Errorf("getDeleteStateObject (%x) error: %w", addr.Bytes(), err))
return nil
}
// If snapshot unavailable or reading from it failed, load from the database
if data == nil {
return nil
start := time.Now()
var err error
data, err = s.trie.GetAccount(addr)
if metrics.EnabledExpensive {
s.AccountReads += time.Since(start)
}
if err != nil {
s.setError(fmt.Errorf("getDeleteStateObject (%x) error: %w", addr.Bytes(), err))
return nil
}
if data == nil {
return nil
}
}
}
// Insert into the live set
obj := newObject(s, addr, data)
s.setStateObject(obj)
return obj
// Insert into the live set
obj := newObject(s, addr, data)
s.setStateObject(obj)
return obj
})
}
func (s *StateDB) setStateObject(object *stateObject) {
@ -1366,7 +1357,7 @@ func (s *StateDB) Finalise(deleteEmptyObjects bool) {
continue
}
if obj.selfDestructed || (deleteEmptyObjects && obj.empty()) {
if obj.selfDestructed || (deleteEmptyObjects && obj.empty()) {
obj.deleted = true
// We need to maintain account deletions explicitly (will remain

8
core/state/statedb_test.go
View file

@ -592,7 +592,7 @@ func TestMVHashMapReadWriteDelete(t *testing.T) {
assert.Equal(t, balance, b)
// Tx3 delete
states[3].Suicide(addr)
states[3].SelfDestruct(addr)
// Within Tx 3, the state should not change before finalize
v = states[3].GetState(addr, key)
@ -648,7 +648,7 @@ func TestMVHashMapRevert(t *testing.T) {
assert.Equal(t, new(big.Int).SetUint64(uint64(200)), b)
assert.Equal(t, common.HexToHash("0x02"), v)
states[1].Suicide(addr)
states[1].SelfDestruct(addr)
states[1].RevertToSnapshot(snapshot)
@ -983,12 +983,12 @@ func TestApplyMVWriteSet(t *testing.T) {
assert.Equal(t, sSingleProcess.IntermediateRoot(true), sClean.IntermediateRoot(true))
// Tx3 write
states[3].Suicide(addr2)
states[3].SelfDestruct(addr2)
states[3].SetCode(addr1, code)
states[3].Finalise(true)
states[3].FlushMVWriteSet()
sSingleProcess.Suicide(addr2)
sSingleProcess.SelfDestruct(addr2)
sSingleProcess.SetCode(addr1, code)
sClean.ApplyMVWriteSet(states[3].MVWriteList())

13
core/state_processor_test.go
View file

@ -48,9 +48,8 @@ func u64(val uint64) *uint64 { return &val }
func TestStateProcessorErrors(t *testing.T) {
var (
cacheConfig = &CacheConfig{
TrieCleanLimit: 154,
TrieCleanJournal: "triecache",
Preimages: true,
TrieCleanLimit: 154,
Preimages: true,
}
config = &params.ChainConfig{
@ -138,7 +137,7 @@ func TestStateProcessorErrors(t *testing.T) {
},
},
}
blockchain, _ = NewBlockChain(db, nil, gspec, nil, beacon.New(ethash.NewFaker()), vm.Config{}, nil, nil)
blockchain, _ = NewBlockChain(db, nil, gspec, nil, beacon.New(ethash.NewFaker()), vm.Config{}, nil, nil, nil)
tooBigInitCode = [params.MaxInitCodeSize + 1]byte{}
)
@ -349,7 +348,7 @@ func TestStateProcessorErrors(t *testing.T) {
},
}
parallelBlockchain, _ = NewParallelBlockChain(db, cacheConfig, gspec, nil, ethash.NewFaker(), vm.Config{ParallelEnable: true, ParallelSpeculativeProcesses: 8}, nil, nil, nil)
blockchain, _ = NewBlockChain(db, nil, gspec, nil, beacon.New(ethash.NewFaker()), vm.Config{}, nil, nil)
blockchain, _ = NewBlockChain(db, nil, gspec, nil, beacon.New(ethash.NewFaker()), vm.Config{}, nil, nil, nil)
)
defer blockchain.Stop()
@ -432,13 +431,13 @@ func TestStateProcessorErrors(t *testing.T) {
}{
{ // ErrMaxInitCodeSizeExceeded
txs: []*types.Transaction{
mkDynamicCreationTx(0, 500000, common.Big0, misc.CalcBaseFee(config, genesis.Header()), tooBigInitCode[:]),
mkDynamicCreationTx(0, 500000, common.Big0, eip1559.CalcBaseFee(config, genesis.Header()), tooBigInitCode[:]),
},
want: "could not apply tx 0 [0x832b54a6c3359474a9f504b1003b2cc1b6fcaa18e4ef369eb45b5d40dad6378f]: max initcode size exceeded: code size 49153 limit 49152",
},
{ // ErrIntrinsicGas: Not enough gas to cover init code
txs: []*types.Transaction{
mkDynamicCreationTx(0, 54299, common.Big0, misc.CalcBaseFee(config, genesis.Header()), smallInitCode[:]),
mkDynamicCreationTx(0, 54299, common.Big0, eip1559.CalcBaseFee(config, genesis.Header()), smallInitCode[:]),
},
want: "could not apply tx 0 [0x39b7436cb432d3662a25626474282c5c4c1a213326fd87e4e18a91477bae98b2]: intrinsic gas too low: have 54299, want 54300",
},

12
core/txpool/legacypool/legacypool.go
View file

@ -37,6 +37,7 @@ import (
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/metrics"
"github.com/ethereum/go-ethereum/params"
"github.com/holiman/uint256"
)
const (
@ -103,6 +104,11 @@ var (
localGauge = metrics.NewRegisteredGauge("txpool/local", nil)
slotsGauge = metrics.NewRegisteredGauge("txpool/slots", nil)
resetCacheGauge = metrics.NewRegisteredGauge("txpool/resetcache", nil)
reinitCacheGauge = metrics.NewRegisteredGauge("txpool/reinittcache", nil)
hitCacheCounter = metrics.NewRegisteredCounter("txpool/cachehit", nil)
missCacheCounter = metrics.NewRegisteredCounter("txpool/cachemiss", nil)
reheapTimer = metrics.NewRegisteredTimer("txpool/reheap", nil)
)
@ -1437,7 +1443,8 @@ func (pool *LegacyPool) promoteExecutables(accounts []common.Address) []*types.T
}
log.Trace("Removed old queued transactions", "count", len(forwards))
// Drop all transactions that are too costly (low balance or out of gas)
drops, _ := list.Filter(pool.currentState.GetBalance(addr), gasLimit)
balUint256, _ := uint256.FromBig(pool.currentState.GetBalance(addr))
drops, _ := list.Filter(balUint256, gasLimit)
for _, tx := range drops {
hash := tx.Hash()
pool.all.Remove(hash)
@ -1638,7 +1645,8 @@ func (pool *LegacyPool) demoteUnexecutables() {
log.Trace("Removed old pending transaction", "hash", hash)
}
// Drop all transactions that are too costly (low balance or out of gas), and queue any invalids back for later
drops, invalids := list.Filter(pool.currentState.GetBalance(addr), gasLimit)
balUint256, _ := uint256.FromBig(pool.currentState.GetBalance(addr))
drops, invalids := list.Filter(balUint256, gasLimit)
for _, tx := range drops {
hash := tx.Hash()
log.Trace("Removed unpayable pending transaction", "hash", hash)

28
core/txpool/legacypool/list.go
View file

@ -463,41 +463,37 @@ func (l *list) Add(tx *types.Transaction, priceBump uint64) (bool, *types.Transa
if old.GasFeeCapCmp(tx) >= 0 || old.GasTipCapCmp(tx) >= 0 {
return false, nil
}
// thresholdFeeCap = oldFC * (100 + priceBump) / 100
a := uint256.NewInt(100 + priceBump)
aFeeCap := uint256.NewInt(0).Mul(a, old.GasFeeCapUint())
aTip := a.Mul(a, old.GasTipCapUint())
a := big.NewInt(100 + int64(priceBump))
aFeeCap := new(big.Int).Mul(a, old.GasFeeCap())
aTip := a.Mul(a, old.GasTipCap())
// thresholdTip = oldTip * (100 + priceBump) / 100
b := cmath.U100
b := big.NewInt(100)
thresholdFeeCap := aFeeCap.Div(aFeeCap, b)
thresholdTip := aTip.Div(aTip, b)
// We have to ensure that both the new fee cap and tip are higher than the
// old ones as well as checking the percentage threshold to ensure that
// this is accurate for low (Wei-level) gas price replacements.
if tx.GasFeeCapUIntLt(thresholdFeeCap) || tx.GasTipCapUIntLt(thresholdTip) {
if tx.GasFeeCapIntCmp(thresholdFeeCap) < 0 || tx.GasTipCapIntCmp(thresholdTip) < 0 {
return false, nil
}
// Old is being replaced, subtract old cost
l.subTotalCost([]*types.Transaction{old})
}
// Add new tx cost to totalcost
l.totalcost.Add(l.totalcost, tx.Cost())
// Otherwise overwrite the old transaction with the current one
l.txs.Put(tx)
if cost := tx.CostUint(); l.costcap == nil || l.costcap.Lt(cost) {
l.costcap = cost
cost := tx.Cost()
costUint256, _ := uint256.FromBig(cost)
if cost = tx.Cost(); l.costcap.Cmp(costUint256) < 0 {
l.costcap = costUint256
}
if gas := tx.Gas(); l.gascap < gas {
l.gascap = gas
}
return true, old
}
@ -648,7 +644,7 @@ func (l *list) subTotalCost(txs []*types.Transaction) {
// then the heap is sorted based on the effective tip based on the given base fee.
// If baseFee is nil then the sorting is based on gasFeeCap.
type priceHeap struct {
baseFee *uint256.Int // heap should always be re-sorted after baseFee is changed
baseFee *big.Int // heap should always be re-sorted after baseFee is changed
list []*types.Transaction
baseFeeMu sync.RWMutex
}
@ -672,7 +668,7 @@ func (h *priceHeap) cmp(a, b *types.Transaction) int {
if h.baseFee != nil {
// Compare effective tips if baseFee is specified
if c := a.EffectiveGasTipTxUintCmp(b, h.baseFee); c != 0 {
if c := a.EffectiveGasTipCmp(b, h.baseFee); c != 0 {
h.baseFeeMu.RUnlock()
return c
@ -872,7 +868,7 @@ func (l *pricedList) Reheap() {
// SetBaseFee updates the base fee and triggers a re-heap. Note that Removed is not
// necessary to call right before SetBaseFee when processing a new block.
func (l *pricedList) SetBaseFee(baseFee *uint256.Int) {
func (l *pricedList) SetBaseFee(baseFee *big.Int) {
l.urgent.baseFeeMu.Lock()
l.urgent.baseFee = baseFee
l.urgent.baseFeeMu.Unlock()

6
core/txpool/txpool.go
View file

@ -383,10 +383,6 @@ func (p *TxPool) ContentFrom(addr common.Address) ([]*types.Transaction, []*type
if len(run) != 0 || len(block) != 0 {
return run, block
}
if err != nil {
errs = append(errs, err)
}
}
return []*types.Transaction{}, []*types.Transaction{}
}
@ -415,8 +411,6 @@ func (p *TxPool) Status(hash common.Hash) TxStatus {
if status := subpool.Status(hash); status != TxStatusUnknown {
return status
}
pool.pendingMu.TryLock()
}
return TxStatusUnknown
}

2
core/types/gen_receipt_json.go
View file

@ -107,7 +107,7 @@ func (r *Receipt) UnmarshalJSON(input []byte) error {
}
r.GasUsed = uint64(*dec.GasUsed)
if dec.EffectiveGasPrice != nil {
r.EffectiveGasPrice = dec.EffectiveGasPrice
r.EffectiveGasPrice = (*big.Int)(dec.EffectiveGasPrice)
}
if dec.BlobGasUsed != nil {
r.BlobGasUsed = uint64(*dec.BlobGasUsed)

256
core/types/transaction.go
View file

@ -18,18 +18,18 @@ package types
import (
"bytes"
"container/heap"
"errors"
"io"
"math/big"
"sync/atomic"
"time"
"github.com/holiman/uint256"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/math"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/rlp"
"github.com/holiman/uint256"
)
var (
@ -55,16 +55,15 @@ type Transaction struct {
time time.Time // Time first seen locally (spam avoidance)
// caches
hash atomic.Pointer[common.Hash]
size atomic.Pointer[uint64]
from atomic.Pointer[sigCache]
hash atomic.Value
size atomic.Value
from atomic.Value
}
// NewTx creates a new transaction.
func NewTx(inner TxData) *Transaction {
tx := new(Transaction)
tx.setDecoded(inner.copy(), 0)
return tx
}
@ -80,11 +79,8 @@ type TxData interface {
data() []byte
gas() uint64
gasPrice() *big.Int
gasPriceU256() *uint256.Int
gasTipCap() *big.Int
gasTipCapU256() *uint256.Int
gasFeeCap() *big.Int
gasFeeCapU256() *uint256.Int
value() *big.Int
nonce() uint64
to() *common.Address
@ -113,11 +109,9 @@ func (tx *Transaction) EncodeRLP(w io.Writer) error {
buf := encodeBufferPool.Get().(*bytes.Buffer)
defer encodeBufferPool.Put(buf)
buf.Reset()
if err := tx.encodeTyped(buf); err != nil {
return err
}
return rlp.Encode(w, buf.Bytes())
}
@ -134,43 +128,35 @@ func (tx *Transaction) MarshalBinary() ([]byte, error) {
if tx.Type() == LegacyTxType {
return rlp.EncodeToBytes(tx.inner)
}
var buf bytes.Buffer
err := tx.encodeTyped(&buf)
return buf.Bytes(), err
}
// DecodeRLP implements rlp.Decoder
func (tx *Transaction) DecodeRLP(s *rlp.Stream) error {
kind, size, err := s.Kind()
switch {
case err != nil:
return err
case kind == rlp.List:
// It's a legacy transaction.
var inner LegacyTx
err := s.Decode(&inner)
if err == nil {
tx.setDecoded(&inner, rlp.ListSize(size))
}
return err
default:
// It's an EIP-2718 typed TX envelope.
var b []byte
if b, err = s.Bytes(); err != nil {
return err
}
inner, err := tx.decodeTyped(b)
if err == nil {
tx.setDecoded(inner, uint64(len(b)))
}
return err
}
}
@ -181,14 +167,11 @@ func (tx *Transaction) UnmarshalBinary(b []byte) error {
if len(b) > 0 && b[0] > 0x7f {
// It's a legacy transaction.
var data LegacyTx
err := rlp.DecodeBytes(b, &data)
if err != nil {
return err
}
tx.setDecoded(&data, uint64(len(b)))
return nil
}
// It's an EIP2718 typed transaction envelope.
@ -196,9 +179,7 @@ func (tx *Transaction) UnmarshalBinary(b []byte) error {
if err != nil {
return err
}
tx.setDecoded(inner, uint64(len(b)))
return nil
}
@ -207,17 +188,14 @@ func (tx *Transaction) decodeTyped(b []byte) (TxData, error) {
if len(b) <= 1 {
return nil, errShortTypedTx
}
switch b[0] {
case AccessListTxType:
var inner AccessListTx
err := rlp.DecodeBytes(b[1:], &inner)
return &inner, err
case DynamicFeeTxType:
var inner DynamicFeeTx
err := rlp.DecodeBytes(b[1:], &inner)
return &inner, err
case BlobTxType:
var inner BlobTx
@ -232,9 +210,8 @@ func (tx *Transaction) decodeTyped(b []byte) (TxData, error) {
func (tx *Transaction) setDecoded(inner TxData, size uint64) {
tx.inner = inner
tx.time = time.Now()
if size > 0 {
tx.size.Store(&size)
tx.size.Store(size)
}
}
@ -244,7 +221,6 @@ func sanityCheckSignature(v *big.Int, r *big.Int, s *big.Int, maybeProtected boo
}
var plainV byte
if isProtectedV(v) {
chainID := deriveChainId(v).Uint64()
plainV = byte(v.Uint64() - 35 - 2*chainID)
@ -258,7 +234,6 @@ func sanityCheckSignature(v *big.Int, r *big.Int, s *big.Int, maybeProtected boo
// must already be equal to the recovery id.
plainV = byte(v.Uint64())
}
if !crypto.ValidateSignatureValues(plainV, r, s, false) {
return ErrInvalidSig
}
@ -307,19 +282,13 @@ func (tx *Transaction) AccessList() AccessList { return tx.inner.accessList() }
func (tx *Transaction) Gas() uint64 { return tx.inner.gas() }
// GasPrice returns the gas price of the transaction.
func (tx *Transaction) GasPrice() *big.Int { return new(big.Int).Set(tx.inner.gasPrice()) }
func (tx *Transaction) GasPriceRef() *big.Int { return tx.inner.gasPrice() }
func (tx *Transaction) GasPriceUint() *uint256.Int { return tx.inner.gasPriceU256() }
func (tx *Transaction) GasPrice() *big.Int { return new(big.Int).Set(tx.inner.gasPrice()) }
// GasTipCap returns the gasTipCap per gas of the transaction.
func (tx *Transaction) GasTipCap() *big.Int { return new(big.Int).Set(tx.inner.gasTipCap()) }
func (tx *Transaction) GasTipCapRef() *big.Int { return tx.inner.gasTipCap() }
func (tx *Transaction) GasTipCapUint() *uint256.Int { return tx.inner.gasTipCapU256() }
func (tx *Transaction) GasTipCap() *big.Int { return new(big.Int).Set(tx.inner.gasTipCap()) }
// GasFeeCap returns the fee cap per gas of the transaction.
func (tx *Transaction) GasFeeCap() *big.Int { return new(big.Int).Set(tx.inner.gasFeeCap()) }
func (tx *Transaction) GasFeeCapRef() *big.Int { return tx.inner.gasFeeCap() }
func (tx *Transaction) GasFeeCapUint() *uint256.Int { return tx.inner.gasFeeCapU256() }
func (tx *Transaction) GasFeeCap() *big.Int { return new(big.Int).Set(tx.inner.gasFeeCap()) }
// BlobGas returns the blob gas limit of the transaction for blob transactions, 0 otherwise.
func (tx *Transaction) BlobGas() uint64 { return tx.inner.blobGas() }
@ -331,8 +300,7 @@ func (tx *Transaction) BlobGasFeeCap() *big.Int { return tx.inner.blobGasFeeCap(
func (tx *Transaction) BlobHashes() []common.Hash { return tx.inner.blobHashes() }
// Value returns the ether amount of the transaction.
func (tx *Transaction) Value() *big.Int { return new(big.Int).Set(tx.inner.value()) }
func (tx *Transaction) ValueRef() *big.Int { return tx.inner.value() }
func (tx *Transaction) Value() *big.Int { return new(big.Int).Set(tx.inner.value()) }
// Nonce returns the sender account nonce of the transaction.
func (tx *Transaction) Nonce() uint64 { return tx.inner.nonce() }
@ -369,14 +337,6 @@ func (tx *Transaction) GasFeeCapIntCmp(other *big.Int) int {
return tx.inner.gasFeeCap().Cmp(other)
}
func (tx *Transaction) GasFeeCapUIntCmp(other *uint256.Int) int {
return tx.inner.gasFeeCapU256().Cmp(other)
}
func (tx *Transaction) GasFeeCapUIntLt(other *uint256.Int) bool {
return tx.inner.gasFeeCapU256().Lt(other)
}
// GasTipCapCmp compares the gasTipCap of two transactions.
func (tx *Transaction) GasTipCapCmp(other *Transaction) int {
return tx.inner.gasTipCap().Cmp(other.inner.gasTipCap())
@ -387,14 +347,6 @@ func (tx *Transaction) GasTipCapIntCmp(other *big.Int) int {
return tx.inner.gasTipCap().Cmp(other)
}
func (tx *Transaction) GasTipCapUIntCmp(other *uint256.Int) int {
return tx.inner.gasTipCapU256().Cmp(other)
}
func (tx *Transaction) GasTipCapUIntLt(other *uint256.Int) bool {
return tx.inner.gasTipCapU256().Lt(other)
}
// EffectiveGasTip returns the effective miner gasTipCap for the given base fee.
// Note: if the effective gasTipCap is negative, this method returns both error
// the actual negative value, _and_ ErrGasFeeCapTooLow
@ -402,14 +354,11 @@ func (tx *Transaction) EffectiveGasTip(baseFee *big.Int) (*big.Int, error) {
if baseFee == nil {
return tx.GasTipCap(), nil
}
var err error
gasFeeCap := tx.GasFeeCap()
if gasFeeCap.Cmp(baseFee) == -1 {
err = ErrGasFeeCapTooLow
}
return math.BigMin(tx.GasTipCap(), gasFeeCap.Sub(gasFeeCap, baseFee)), err
}
@ -425,7 +374,6 @@ func (tx *Transaction) EffectiveGasTipCmp(other *Transaction, baseFee *big.Int)
if baseFee == nil {
return tx.GasTipCapCmp(other)
}
return tx.EffectiveGasTipValue(baseFee).Cmp(other.EffectiveGasTipValue(baseFee))
}
@ -434,7 +382,6 @@ func (tx *Transaction) EffectiveGasTipIntCmp(other *big.Int, baseFee *big.Int) i
if baseFee == nil {
return tx.GasTipCapIntCmp(other)
}
return tx.EffectiveGasTipValue(baseFee).Cmp(other)
}
@ -464,7 +411,7 @@ func (tx *Transaction) Time() time.Time {
// Hash returns the transaction hash.
func (tx *Transaction) Hash() common.Hash {
if hash := tx.hash.Load(); hash != nil {
return *hash
return hash.(common.Hash)
}
var h common.Hash
@ -473,9 +420,7 @@ func (tx *Transaction) Hash() common.Hash {
} else {
h = prefixedRlpHash(tx.Type(), tx.inner)
}
tx.hash.Store(&h)
tx.hash.Store(h)
return h
}
@ -483,9 +428,8 @@ func (tx *Transaction) Hash() common.Hash {
// and returning it, or returning a previously cached value.
func (tx *Transaction) Size() uint64 {
if size := tx.size.Load(); size != nil {
return *size
return size.(uint64)
}
c := writeCounter(0)
rlp.Encode(&c, &tx.inner)
@ -493,9 +437,7 @@ func (tx *Transaction) Size() uint64 {
if tx.Type() != LegacyTxType {
size += 1 // type byte
}
tx.size.Store(&size)
tx.size.Store(size)
return size
}
@ -506,10 +448,8 @@ func (tx *Transaction) WithSignature(signer Signer, sig []byte) (*Transaction, e
if err != nil {
return nil, err
}
cpy := tx.inner.copy()
cpy.setSignatureValues(signer.ChainID(), v, r, s)
return &Transaction{inner: cpy, time: tx.time}, nil
}
@ -581,8 +521,172 @@ func copyAddressPtr(a *common.Address) *common.Address {
if a == nil {
return nil
}
cpy := *a
return &cpy
}
// TxWithMinerFee wraps a transaction with its gas price or effective miner gasTipCap
type TxWithMinerFee struct {
tx *Transaction
minerFee *uint256.Int
}
// TODO - Arpit
// NewTxWithMinerFee creates a wrapped transaction, calculating the effective
// miner gasTipCap if a base fee is provided.
// Returns error in case of a negative effective miner gasTipCap.
func NewTxWithMinerFee(tx *Transaction, baseFee *uint256.Int) (*TxWithMinerFee, error) {
// minerFee, err := tx.EffectiveGasTipUnit(baseFee)
// if err != nil {
// return nil, err
// }
return &TxWithMinerFee{
tx: tx,
minerFee: uint256.NewInt(1),
}, nil
}
// TxByPriceAndTime implements both the sort and the heap interface, making it useful
// for all at once sorting as well as individually adding and removing elements.
type TxByPriceAndTime []*TxWithMinerFee
func (s TxByPriceAndTime) Len() int { return len(s) }
func (s TxByPriceAndTime) Less(i, j int) bool {
// If the prices are equal, use the time the transaction was first seen for
// deterministic sorting
cmp := s[i].minerFee.Cmp(s[j].minerFee)
if cmp == 0 {
return s[i].tx.time.Before(s[j].tx.time)
}
return cmp > 0
}
func (s TxByPriceAndTime) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
func (s *TxByPriceAndTime) Push(x interface{}) {
*s = append(*s, x.(*TxWithMinerFee))
}
func (s *TxByPriceAndTime) Pop() interface{} {
old := *s
n := len(old)
x := old[n-1]
old[n-1] = nil
*s = old[0 : n-1]
return x
}
// TransactionsByPriceAndNonce represents a set of transactions that can return
// transactions in a profit-maximizing sorted order, while supporting removing
// entire batches of transactions for non-executable accounts.
type TransactionsByPriceAndNonce struct {
txs map[common.Address]Transactions // Per account nonce-sorted list of transactions
heads TxByPriceAndTime // Next transaction for each unique account (price heap)
signer Signer // Signer for the set of transactions
baseFee *uint256.Int // Current base fee
}
// NewTransactionsByPriceAndNonce creates a transaction set that can retrieve
// price sorted transactions in a nonce-honouring way.
//
// Note, the input map is reowned so the caller should not interact any more with
// if after providing it to the constructor.
/*
func NewTransactionsByPriceAndNonce(signer Signer, txs map[common.Address]Transactions, baseFee *big.Int) *TransactionsByPriceAndNonce {
// Initialize a price and received time based heap with the head transactions
heads := make(TxByPriceAndTime, 0, len(txs))
for from, accTxs := range txs {
if len(accTxs) == 0 {
continue
}
acc, _ := Sender(signer, accTxs[0])
wrapped, err := NewTxWithMinerFee(accTxs[0], baseFee)
// Remove transaction if sender doesn't match from, or if wrapping fails.
if acc != from || err != nil {
delete(txs, from)
continue
}
heads = append(heads, wrapped)
txs[from] = accTxs[1:]
}
heap.Init(&heads)
// Assemble and return the transaction set
return &TransactionsByPriceAndNonce{
txs: txs,
heads: heads,
signer: signer,
baseFee: baseFee,
}
}*/
func NewTransactionsByPriceAndNonce(signer Signer, txs map[common.Address]Transactions, baseFee *uint256.Int) *TransactionsByPriceAndNonce {
// Initialize a price and received time based heap with the head transactions
heads := make(TxByPriceAndTime, 0, len(txs))
for from, accTxs := range txs {
if len(accTxs) == 0 {
continue
}
acc, _ := Sender(signer, accTxs[0])
wrapped, err := NewTxWithMinerFee(accTxs[0], baseFee)
// Remove transaction if sender doesn't match from, or if wrapping fails.
if acc != from || err != nil {
delete(txs, from)
continue
}
heads = append(heads, wrapped)
txs[from] = accTxs[1:]
}
heap.Init(&heads)
// Assemble and return the transaction set
return &TransactionsByPriceAndNonce{
txs: txs,
heads: heads,
signer: signer,
baseFee: baseFee,
}
}
// Peek returns the next transaction by price.
func (t *TransactionsByPriceAndNonce) Peek() *Transaction {
if len(t.heads) == 0 {
return nil
}
return t.heads[0].tx
}
// Shift replaces the current best head with the next one from the same account.
func (t *TransactionsByPriceAndNonce) Shift() {
acc, _ := Sender(t.signer, t.heads[0].tx)
if txs, ok := t.txs[acc]; ok && len(txs) > 0 {
if wrapped, err := NewTxWithMinerFee(txs[0], t.baseFee); err == nil {
t.heads[0], t.txs[acc] = wrapped, txs[1:]
heap.Fix(&t.heads, 0)
return
}
}
heap.Pop(&t.heads)
}
func (t *TransactionsByPriceAndNonce) GetTxs() int {
return len(t.txs)
}
// Pop removes the best transaction, *not* replacing it with the next one from
// the same account. This should be used when a transaction cannot be executed
// and hence all subsequent ones should be discarded from the same account.
func (t *TransactionsByPriceAndNonce) Pop() {
heap.Pop(&t.heads)
}

22
core/types/transaction_marshalling.go
View file

@ -143,12 +143,10 @@ func (tx *Transaction) MarshalJSON() ([]byte, error) {
yparity := itx.V.Uint64()
enc.YParity = (*hexutil.Uint64)(&yparity)
}
return json.Marshal(&enc)
}
// UnmarshalJSON unmarshals from JSON.
// nolint:gocognit
func (tx *Transaction) UnmarshalJSON(input []byte) error {
var dec txJSON
err := json.Unmarshal(input, &dec)
@ -158,7 +156,6 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
// Decode / verify fields according to transaction type.
var inner TxData
switch dec.Type {
case LegacyTxType:
var itx LegacyTx
@ -166,7 +163,6 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
if dec.Nonce == nil {
return errors.New("missing required field 'nonce' in transaction")
}
itx.Nonce = uint64(*dec.Nonce)
if dec.To != nil {
itx.To = dec.To
@ -174,7 +170,6 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
if dec.Gas == nil {
return errors.New("missing required field 'gas' in transaction")
}
itx.Gas = uint64(*dec.Gas)
if dec.GasPrice == nil {
return errors.New("missing required field 'gasPrice' in transaction")
@ -183,7 +178,6 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
if dec.Value == nil {
return errors.New("missing required field 'value' in transaction")
}
itx.Value = (*big.Int)(dec.Value)
if dec.Input == nil {
return errors.New("missing required field 'input' in transaction")
@ -194,13 +188,11 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
if dec.R == nil {
return errors.New("missing required field 'r' in transaction")
}
itx.R = (*big.Int)(dec.R)
// signature S
if dec.S == nil {
return errors.New("missing required field 's' in transaction")
}
itx.S = (*big.Int)(dec.S)
// signature V
if dec.V == nil {
@ -219,12 +211,10 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
if dec.ChainID == nil {
return errors.New("missing required field 'chainId' in transaction")
}
itx.ChainID = (*big.Int)(dec.ChainID)
if dec.Nonce == nil {
return errors.New("missing required field 'nonce' in transaction")
}
itx.Nonce = uint64(*dec.Nonce)
if dec.To != nil {
itx.To = dec.To
@ -232,7 +222,6 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
if dec.Gas == nil {
return errors.New("missing required field 'gas' in transaction")
}
itx.Gas = uint64(*dec.Gas)
if dec.GasPrice == nil {
return errors.New("missing required field 'gasPrice' in transaction")
@ -241,7 +230,6 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
if dec.Value == nil {
return errors.New("missing required field 'value' in transaction")
}
itx.Value = (*big.Int)(dec.Value)
if dec.Input == nil {
return errors.New("missing required field 'input' in transaction")
@ -255,13 +243,11 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
if dec.R == nil {
return errors.New("missing required field 'r' in transaction")
}
itx.R = (*big.Int)(dec.R)
// signature S
if dec.S == nil {
return errors.New("missing required field 's' in transaction")
}
itx.S = (*big.Int)(dec.S)
// signature V
itx.V, err = dec.yParityValue()
@ -280,12 +266,10 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
if dec.ChainID == nil {
return errors.New("missing required field 'chainId' in transaction")
}
itx.ChainID = (*big.Int)(dec.ChainID)
if dec.Nonce == nil {
return errors.New("missing required field 'nonce' in transaction")
}
itx.Nonce = uint64(*dec.Nonce)
if dec.To != nil {
itx.To = dec.To
@ -297,18 +281,14 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
if dec.MaxPriorityFeePerGas == nil {
return errors.New("missing required field 'maxPriorityFeePerGas' for txdata")
}
itx.GasTipCap = (*big.Int)(dec.MaxPriorityFeePerGas)
if dec.MaxFeePerGas == nil {
return errors.New("missing required field 'maxFeePerGas' for txdata")
}
itx.GasFeeCap = (*big.Int)(dec.MaxFeePerGas)
if dec.Value == nil {
return errors.New("missing required field 'value' in transaction")
}
itx.Value = (*big.Int)(dec.Value)
if dec.Input == nil {
return errors.New("missing required field 'input' in transaction")
@ -325,13 +305,11 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
if dec.R == nil {
return errors.New("missing required field 'r' in transaction")
}
itx.R = (*big.Int)(dec.R)
// signature S
if dec.S == nil {
return errors.New("missing required field 's' in transaction")
}
itx.S = (*big.Int)(dec.S)
// signature V
itx.V, err = dec.yParityValue()

94
core/types/transaction_signing.go
View file

@ -39,7 +39,6 @@ type sigCache struct {
// MakeSigner returns a Signer based on the given chain config and block number.
func MakeSigner(config *params.ChainConfig, blockNumber *big.Int, blockTime uint64) Signer {
var signer Signer
switch {
case config.IsCancun(blockNumber, blockTime):
signer = NewCancunSigner(config.ChainID)
@ -54,7 +53,6 @@ func MakeSigner(config *params.ChainConfig, blockNumber *big.Int, blockTime uint
default:
signer = FrontierSigner{}
}
return signer
}
@ -73,16 +71,13 @@ func LatestSigner(config *params.ChainConfig) Signer {
if config.LondonBlock != nil {
return NewLondonSigner(config.ChainID)
}
if config.BerlinBlock != nil {
return NewEIP2930Signer(config.ChainID)
}
if config.EIP155Block != nil {
return NewEIP155Signer(config.ChainID)
}
}
return HomesteadSigner{}
}
@ -103,12 +98,10 @@ func LatestSignerForChainID(chainID *big.Int) Signer {
// SignTx signs the transaction using the given signer and private key.
func SignTx(tx *Transaction, s Signer, prv *ecdsa.PrivateKey) (*Transaction, error) {
h := s.Hash(tx)
sig, err := crypto.Sign(h[:], prv)
if err != nil {
return nil, err
}
return tx.WithSignature(s, sig)
}
@ -116,12 +109,10 @@ func SignTx(tx *Transaction, s Signer, prv *ecdsa.PrivateKey) (*Transaction, err
func SignNewTx(prv *ecdsa.PrivateKey, s Signer, txdata TxData) (*Transaction, error) {
tx := NewTx(txdata)
h := s.Hash(tx)
sig, err := crypto.Sign(h[:], prv)
if err != nil {
return nil, err
}
return tx.WithSignature(s, sig)
}
@ -132,7 +123,6 @@ func MustSignNewTx(prv *ecdsa.PrivateKey, s Signer, txdata TxData) *Transaction
if err != nil {
panic(err)
}
return tx
}
@ -145,11 +135,12 @@ func MustSignNewTx(prv *ecdsa.PrivateKey, s Signer, txdata TxData) *Transaction
// not match the signer used in the current call.
func Sender(signer Signer, tx *Transaction) (common.Address, error) {
if sc := tx.from.Load(); sc != nil {
sigCache := sc.(sigCache)
// If the signer used to derive from in a previous
// call is not the same as used current, invalidate
// the cache.
if sc.signer.Equal(signer) {
return sc.from, nil
if sigCache.signer.Equal(signer) {
return sigCache.from, nil
}
}
@ -157,9 +148,7 @@ func Sender(signer Signer, tx *Transaction) (common.Address, error) {
if err != nil {
return common.Address{}, err
}
tx.from.Store(&sigCache{signer: signer, from: addr})
tx.from.Store(sigCache{signer: signer, from: addr})
return addr, nil
}
@ -270,16 +259,13 @@ func (s londonSigner) Sender(tx *Transaction) (common.Address, error) {
if tx.Type() != DynamicFeeTxType {
return s.eip2930Signer.Sender(tx)
}
V, R, S := tx.RawSignatureValues()
// DynamicFee txs are defined to use 0 and 1 as their recovery
// id, add 27 to become equivalent to unprotected Homestead signatures.
V = new(big.Int).Add(V, big.NewInt(27))
if tx.ChainId().Cmp(s.chainId) != 0 {
return common.Address{}, fmt.Errorf("%w: have %d want %d", ErrInvalidChainId, tx.ChainId(), s.chainId)
}
return recoverPlain(s.Hash(tx), R, S, V, true)
}
@ -298,10 +284,8 @@ func (s londonSigner) SignatureValues(tx *Transaction, sig []byte) (R, S, V *big
if txdata.ChainID.Sign() != 0 && txdata.ChainID.Cmp(s.chainId) != 0 {
return nil, nil, nil, fmt.Errorf("%w: have %d want %d", ErrInvalidChainId, txdata.ChainID, s.chainId)
}
R, S, _ = decodeSignature(sig)
V = big.NewInt(int64(sig[64]))
return R, S, V, nil
}
@ -311,7 +295,6 @@ func (s londonSigner) Hash(tx *Transaction) common.Hash {
if tx.Type() != DynamicFeeTxType {
return s.eip2930Signer.Hash(tx)
}
return prefixedRlpHash(
tx.Type(),
[]interface{}{
@ -346,13 +329,11 @@ func (s eip2930Signer) Equal(s2 Signer) bool {
func (s eip2930Signer) Sender(tx *Transaction) (common.Address, error) {
V, R, S := tx.RawSignatureValues()
switch tx.Type() {
case LegacyTxType:
if !tx.Protected() {
return HomesteadSigner{}.Sender(tx)
}
V = new(big.Int).Sub(V, s.chainIdMul)
V.Sub(V, big8)
case AccessListTxType:
@ -362,11 +343,9 @@ func (s eip2930Signer) Sender(tx *Transaction) (common.Address, error) {
default:
return common.Address{}, ErrTxTypeNotSupported
}
if tx.ChainId().Cmp(s.chainId) != 0 {
return common.Address{}, fmt.Errorf("%w: have %d want %d", ErrInvalidChainId, tx.ChainId(), s.chainId)
}
return recoverPlain(s.Hash(tx), R, S, V, true)
}
@ -380,13 +359,11 @@ func (s eip2930Signer) SignatureValues(tx *Transaction, sig []byte) (R, S, V *bi
if txdata.ChainID.Sign() != 0 && txdata.ChainID.Cmp(s.chainId) != 0 {
return nil, nil, nil, fmt.Errorf("%w: have %d want %d", ErrInvalidChainId, txdata.ChainID, s.chainId)
}
R, S, _ = decodeSignature(sig)
V = big.NewInt(int64(sig[64]))
default:
return nil, nil, nil, ErrTxTypeNotSupported
}
return R, S, V, nil
}
@ -436,7 +413,6 @@ func NewEIP155Signer(chainId *big.Int) EIP155Signer {
if chainId == nil {
chainId = new(big.Int)
}
return EIP155Signer{
chainId: chainId,
chainIdMul: new(big.Int).Mul(chainId, big.NewInt(2)),
@ -458,19 +434,15 @@ func (s EIP155Signer) Sender(tx *Transaction) (common.Address, error) {
if tx.Type() != LegacyTxType {
return common.Address{}, ErrTxTypeNotSupported
}
if !tx.Protected() {
return HomesteadSigner{}.Sender(tx)
}
if tx.ChainId().Cmp(s.chainId) != 0 {
return common.Address{}, fmt.Errorf("%w: have %d want %d", ErrInvalidChainId, tx.ChainId(), s.chainId)
}
V, R, S := tx.RawSignatureValues()
V = new(big.Int).Sub(V, s.chainIdMul)
V.Sub(V, big8)
return recoverPlain(s.Hash(tx), R, S, V, true)
}
@ -480,13 +452,11 @@ func (s EIP155Signer) SignatureValues(tx *Transaction, sig []byte) (R, S, V *big
if tx.Type() != LegacyTxType {
return nil, nil, nil, ErrTxTypeNotSupported
}
R, S, V = decodeSignature(sig)
if s.chainId.Sign() != 0 {
V = big.NewInt(int64(sig[64] + 35))
V.Add(V, s.chainIdMul)
}
return R, S, V, nil
}
@ -527,9 +497,7 @@ func (hs HomesteadSigner) Sender(tx *Transaction) (common.Address, error) {
if tx.Type() != LegacyTxType {
return common.Address{}, ErrTxTypeNotSupported
}
v, r, s := tx.RawSignatureValues()
return recoverPlain(hs.Hash(tx), r, s, v, true)
}
@ -550,9 +518,7 @@ func (fs FrontierSigner) Sender(tx *Transaction) (common.Address, error) {
if tx.Type() != LegacyTxType {
return common.Address{}, ErrTxTypeNotSupported
}
v, r, s := tx.RawSignatureValues()
return recoverPlain(fs.Hash(tx), r, s, v, false)
}
@ -562,9 +528,7 @@ func (fs FrontierSigner) SignatureValues(tx *Transaction, sig []byte) (r, s, v *
if tx.Type() != LegacyTxType {
return nil, nil, nil, ErrTxTypeNotSupported
}
r, s, v = decodeSignature(sig)
return r, s, v, nil
}
@ -573,59 +537,21 @@ func (fs FrontierSigner) SignatureValues(tx *Transaction, sig []byte) (r, s, v *
func (fs FrontierSigner) Hash(tx *Transaction) common.Hash {
return rlpHash([]interface{}{
tx.Nonce(),
tx.GasPriceRef(),
tx.GasPrice(),
tx.Gas(),
tx.To(),
tx.ValueRef(),
tx.Value(),
tx.Data(),
})
}
// FakeSigner implements the Signer interface and accepts unprotected transactions
type FakeSigner struct{ londonSigner }
var _ Signer = FakeSigner{}
func NewFakeSigner(chainId *big.Int) Signer {
signer := NewLondonSigner(chainId)
ls, _ := signer.(londonSigner)
return FakeSigner{londonSigner: ls}
}
func (f FakeSigner) Sender(tx *Transaction) (common.Address, error) {
return f.londonSigner.Sender(tx)
}
func (f FakeSigner) SignatureValues(tx *Transaction, sig []byte) (r, s, v *big.Int, err error) {
return f.londonSigner.SignatureValues(tx, sig)
}
func (f FakeSigner) ChainID() *big.Int {
return f.londonSigner.ChainID()
}
// Hash returns 'signature hash', i.e. the transaction hash that is signed by the
// private key. This hash does not uniquely identify the transaction.
func (f FakeSigner) Hash(tx *Transaction) common.Hash {
return f.londonSigner.Hash(tx)
}
// Equal returns true if the given signer is the same as the receiver.
func (f FakeSigner) Equal(Signer) bool {
// Always return true
return true
}
func decodeSignature(sig []byte) (r, s, v *big.Int) {
if len(sig) != crypto.SignatureLength {
panic(fmt.Sprintf("wrong size for signature: got %d, want %d", len(sig), crypto.SignatureLength))
}
r = new(big.Int).SetBytes(sig[:32])
s = new(big.Int).SetBytes(sig[32:64])
v = new(big.Int).SetBytes([]byte{sig[64] + 27})
return r, s, v
}
@ -633,7 +559,6 @@ func recoverPlain(sighash common.Hash, R, S, Vb *big.Int, homestead bool) (commo
if Vb.BitLen() > 8 {
return common.Address{}, ErrInvalidSig
}
V := byte(Vb.Uint64() - 27)
if !crypto.ValidateSignatureValues(V, R, S, homestead) {
return common.Address{}, ErrInvalidSig
@ -649,15 +574,11 @@ func recoverPlain(sighash common.Hash, R, S, Vb *big.Int, homestead bool) (commo
if err != nil {
return common.Address{}, err
}
if len(pub) == 0 || pub[0] != 4 {
return common.Address{}, errors.New("invalid public key")
}
var addr common.Address
copy(addr[:], crypto.Keccak256(pub[1:])[12:])
return addr, nil
}
@ -668,11 +589,8 @@ func deriveChainId(v *big.Int) *big.Int {
if v == 27 || v == 28 {
return new(big.Int)
}
return new(big.Int).SetUint64((v - 35) / 2)
}
v = new(big.Int).Sub(v, big.NewInt(35))
return v.Div(v, big.NewInt(2))
}

28
core/types/tx_legacy.go
View file

@ -19,21 +19,18 @@ package types
import (
"math/big"
"github.com/holiman/uint256"
"github.com/ethereum/go-ethereum/common"
)
// LegacyTx is the transaction data of the original Ethereum transactions.
type LegacyTx struct {
Nonce uint64 // nonce of sender account
GasPrice *big.Int // wei per gas
gasPriceUint256 *uint256.Int // wei per gas
Gas uint64 // gas limit
To *common.Address `rlp:"nil"` // nil means contract creation
Value *big.Int // wei amount
Data []byte // contract invocation input data
V, R, S *big.Int // signature values
Nonce uint64 // nonce of sender account
GasPrice *big.Int // wei per gas
Gas uint64 // gas limit
To *common.Address `rlp:"nil"` // nil means contract creation
Value *big.Int // wei amount
Data []byte // contract invocation input data
V, R, S *big.Int // signature values
}
// NewTransaction creates an unsigned legacy transaction.
@ -78,29 +75,18 @@ func (tx *LegacyTx) copy() TxData {
if tx.Value != nil {
cpy.Value.Set(tx.Value)
}
if tx.GasPrice != nil {
cpy.GasPrice.Set(tx.GasPrice)
if cpy.gasPriceUint256 != nil {
cpy.gasPriceUint256.Set(tx.gasPriceUint256)
} else {
cpy.gasPriceUint256, _ = uint256.FromBig(tx.GasPrice)
}
}
if tx.V != nil {
cpy.V.Set(tx.V)
}
if tx.R != nil {
cpy.R.Set(tx.R)
}
if tx.S != nil {
cpy.S.Set(tx.S)
}
return cpy
}

2
eth/api_backend.go
View file

@ -334,7 +334,7 @@ func (b *EthAPIBackend) SendTx(ctx context.Context, signedTx *types.Transaction)
}
func (b *EthAPIBackend) GetPoolTransactions() (types.Transactions, error) {
pending := b.eth.txPool.Pending(context.Background(), false)
pending := b.eth.txPool.Pending(false)
var txs types.Transactions

2
eth/api_debug.go
View file

@ -118,7 +118,7 @@ func (api *DebugAPI) GetBadBlocks(ctx context.Context) ([]*BadBlockArgs, error)
} else {
blockRlp = fmt.Sprintf("%#x", rlpBytes)
}
blockJSON = ethapi.RPCMarshalBlock(block, true, true, api.eth.APIBackend.ChainConfig())
blockJSON = ethapi.RPCMarshalBlock(block, true, true, api.eth.APIBackend.ChainConfig(), api.eth.ChainDb())
results = append(results, &BadBlockArgs{
Hash: block.Hash(),
RLP: blockRlp,

2
eth/backend.go
View file

@ -269,7 +269,7 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) {
return nil, err
}
_ = ethereum.engine.VerifyHeader(ethereum.blockchain, ethereum.blockchain.CurrentHeader(), true) // TODO think on it
_ = ethereum.engine.VerifyHeader(ethereum.blockchain, ethereum.blockchain.CurrentHeader()) // TODO think on it
// BOR changes
ethereum.APIBackend.gpo.ProcessCache()

2
eth/downloader/downloader_test.go
View file

@ -94,7 +94,7 @@ func newTesterWithNotification(t *testing.T, success func()) *downloadTester {
}
//nolint: staticcheck
tester.downloader = New(0, db, new(event.TypeMux), tester.chain, nil, tester.dropPeer, success, whitelist.NewService(10))
tester.downloader = New(db, new(event.TypeMux), tester.chain, nil, tester.dropPeer, success, whitelist.NewService(10))
return tester
}

11
eth/ethconfig/config.go
View file

@ -131,6 +131,7 @@ type Config struct {
TrieTimeout time.Duration
SnapshotCache int
Preimages bool
TriesInMemory uint64
// This is the number of blocks for which logs will be cached in the filter system.
FilterLogCacheSize int
@ -199,7 +200,7 @@ type Config struct {
}
// CreateConsensusEngine creates a consensus engine for the given chain configuration.
func CreateConsensusEngine(chainConfig *params.ChainConfig, ethConfig *Config, db ethdb.Database, blockchainAPI *ethapi.BlockChainAPI) consensus.Engine {
func CreateConsensusEngine(chainConfig *params.ChainConfig, ethConfig *Config, db ethdb.Database, blockchainAPI *ethapi.BlockChainAPI) (consensus.Engine, error) {
var engine consensus.Engine
// nolint:nestif
if chainConfig.Clique != nil {
@ -212,7 +213,7 @@ func CreateConsensusEngine(chainConfig *params.ChainConfig, ethConfig *Config, d
spanner := span.NewChainSpanner(blockchainAPI, contract.ValidatorSet(), chainConfig, common.HexToAddress(chainConfig.Bor.ValidatorContract))
if ethConfig.WithoutHeimdall {
return bor.New(chainConfig, db, blockchainAPI, spanner, nil, genesisContractsClient, ethConfig.DevFakeAuthor)
return bor.New(chainConfig, db, blockchainAPI, spanner, nil, genesisContractsClient, ethConfig.DevFakeAuthor), nil
} else {
if ethConfig.DevFakeAuthor {
log.Warn("Sanitizing DevFakeAuthor", "Use DevFakeAuthor with", "--bor.withoutheimdall")
@ -227,13 +228,13 @@ func CreateConsensusEngine(chainConfig *params.ChainConfig, ethConfig *Config, d
heimdallClient = heimdall.NewHeimdallClient(ethConfig.HeimdallURL)
}
return bor.New(chainConfig, db, blockchainAPI, spanner, heimdallClient, genesisContractsClient, false)
return bor.New(chainConfig, db, blockchainAPI, spanner, heimdallClient, genesisContractsClient, false), nil
}
} else if !config.TerminalTotalDifficultyPassed {
} else if !chainConfig.TerminalTotalDifficultyPassed {
return nil, errors.New("ethash is only supported as a historical component of already merged networks")
} else {
engine = ethash.NewFaker()
}
return beacon.New(engine)
return beacon.New(engine), nil
}

41
eth/fetcher/tx_fetcher.go
View file

@ -183,35 +183,34 @@ type TxFetcher struct {
// NewTxFetcher creates a transaction fetcher to retrieve transaction
// based on hash announcements.
func NewTxFetcher(hasTx func(common.Hash) bool, addTxs func([]*types.Transaction) []error, fetchTxs func(string, []common.Hash) error, txArrivalWait time.Duration) *TxFetcher {
func NewTxFetcher(hasTx func(common.Hash) bool, addTxs func([]*txpool.Transaction) []error, fetchTxs func(string, []common.Hash) error, txArrivalWait time.Duration) *TxFetcher {
return NewTxFetcherForTests(hasTx, addTxs, fetchTxs, mclock.System{}, nil, txArrivalWait)
}
// NewTxFetcherForTests is a testing method to mock out the realtime clock with
// a simulated version and the internal randomness with a deterministic one.
func NewTxFetcherForTests(
hasTx func(common.Hash) bool, addTxs func([]*types.Transaction) []error, fetchTxs func(string, []common.Hash) error,
hasTx func(common.Hash) bool, addTxs func([]*txpool.Transaction) []error, fetchTxs func(string, []common.Hash) error,
clock mclock.Clock, rand *mrand.Rand, txArrivalWait time.Duration) *TxFetcher {
return &TxFetcher{
notify: make(chan *txAnnounce),
cleanup: make(chan *txDelivery),
drop: make(chan *txDrop),
quit: make(chan struct{}),
waitlist: make(map[common.Hash]map[string]struct{}),
waittime: make(map[common.Hash]mclock.AbsTime),
waitslots: make(map[string]map[common.Hash]struct{}),
announces: make(map[string]map[common.Hash]struct{}),
announced: make(map[common.Hash]map[string]struct{}),
fetching: make(map[common.Hash]string),
requests: make(map[string]*txRequest),
alternates: make(map[common.Hash]map[string]struct{}),
underpriced: mapset.NewSet[common.Hash](),
hasTx: hasTx,
addTxs: addTxs,
fetchTxs: fetchTxs,
clock: clock,
rand: rand,
txArrivalWait: txArrivalWait,
notify: make(chan *txAnnounce),
cleanup: make(chan *txDelivery),
drop: make(chan *txDrop),
quit: make(chan struct{}),
waitlist: make(map[common.Hash]map[string]struct{}),
waittime: make(map[common.Hash]mclock.AbsTime),
waitslots: make(map[string]map[common.Hash]struct{}),
announces: make(map[string]map[common.Hash]struct{}),
announced: make(map[common.Hash]map[string]struct{}),
fetching: make(map[common.Hash]string),
requests: make(map[string]*txRequest),
alternates: make(map[common.Hash]map[string]struct{}),
underpriced: mapset.NewSet[common.Hash](),
hasTx: hasTx,
addTxs: addTxs,
fetchTxs: fetchTxs,
clock: clock,
rand: rand,
}
}

2
eth/filters/filter_test.go
View file

@ -253,7 +253,7 @@ func TestFilters(t *testing.T) {
}
})
var l uint64
bc, err := core.NewBlockChain(db, nil, gspec, nil, ethash.NewFaker(), vm.Config{}, nil, &l)
bc, err := core.NewBlockChain(db, nil, gspec, nil, ethash.NewFaker(), vm.Config{}, nil, &l, nil)
if err != nil {
t.Fatal(err)
}

7
eth/filters/test_backend.go
View file

@ -96,15 +96,18 @@ func (b *TestBackend) HeaderByHash(ctx context.Context, hash common.Hash) (*type
}
func (b *TestBackend) GetReceipts(ctx context.Context, hash common.Hash) (types.Receipts, error) {
if number := rawdb.ReadHeaderNumber(b.DB, hash); number != nil {
return rawdb.ReadReceipts(b.DB, hash, *number, params.TestChainConfig), nil
block := rawdb.ReadBlock(b.DB, hash, *number)
return rawdb.ReadReceipts(b.DB, hash, *number, block.Time(), params.TestChainConfig), nil
}
return nil, nil
}
func (b *TestBackend) GetLogs(ctx context.Context, hash common.Hash, number uint64) ([][]*types.Log, error) {
receipts := rawdb.ReadReceipts(b.DB, hash, number, params.TestChainConfig)
block := rawdb.ReadBlock(b.DB, hash, number)
receipts := rawdb.ReadReceipts(b.DB, hash, number, block.Time(), params.TestChainConfig)
logs := make([][]*types.Log, len(receipts))
for i, receipt := range receipts {

10
eth/sync.go
View file

@ -19,7 +19,6 @@ package eth
import (
"errors"
"math/big"
"sync/atomic"
"time"
"github.com/ethereum/go-ethereum/common"
@ -287,14 +286,6 @@ func (h *handler) doSync(op *chainSyncOp) error {
h.acceptTxs.Store(true)
head := h.chain.CurrentBlock()
if head.Number.Uint64() >= h.checkpointNumber {
// Checkpoint passed, sanity check the timestamp to have a fallback mechanism
// for non-checkpointed (number = 0) private networks.
if head.Time >= uint64(time.Now().AddDate(0, -1, 0).Unix()) {
atomic.StoreUint32(&h.acceptTxs, 1)
}
}
if head.Number.Uint64() > 0 {
// We've completed a sync cycle, notify all peers of new state. This path is
// essential in star-topology networks where a gateway node needs to notify
@ -306,6 +297,5 @@ func (h *handler) doSync(op *chainSyncOp) error {
h.BroadcastBlock(block, false)
}
}
return nil
}

41
eth/tracers/api.go
View file

@ -786,44 +786,15 @@ func (api *API) traceBlock(ctx context.Context, block *types.Block, config *Trac
if ioflag {
statedb.AddEmptyMVHashMap()
}
// Native tracers have low overhead
var (
txs = block.Transactions()
blockHash = block.Hash()
is158 = api.backend.ChainConfig().IsEIP158(block.Number())
blockCtx = core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil)
signer = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time())
results = make([]*txTraceResult, len(txs))
)
for i, tx := range txs {
// Generate the next state snapshot fast without tracing
msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee())
txctx := &Context{
BlockHash: blockHash,
BlockNumber: block.Number(),
TxIndex: i,
TxHash: tx.Hash(),
}
res, err := api.traceTx(ctx, msg, txctx, blockCtx, statedb, config)
if err != nil {
return nil, err
}
results[i] = &txTraceResult{TxHash: tx.Hash(), Result: res}
// Finalize the state so any modifications are written to the trie
// Only delete empty objects if EIP158/161 (a.k.a Spurious Dragon) is in effect
statedb.Finalise(is158)
}
return results, nil
}
// Execute all the transaction contained within the block concurrently
var (
txs, stateSyncPresent = api.getAllBlockTransactions(ctx, block)
blockHash = block.Hash()
blockCtx = core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil)
signer = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time())
results = make([]*txTraceResult, len(txs))
pend sync.WaitGroup
blockHash = block.Hash()
blockCtx = core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil)
signer = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time())
results = make([]*txTraceResult, len(txs))
pend sync.WaitGroup
)
threads := runtime.NumCPU()
@ -1407,7 +1378,7 @@ func overrideConfig(original *params.ChainConfig, override *params.ChainConfig)
canon = false
}
if timestamp := override.VerkleTime; timestamp != nil {
copy.VerkleTime = timestamp
chainConfigCopy.VerkleTime = timestamp
canon = false
}

7
eth/tracers/api_bor.go
View file

@ -44,10 +44,7 @@ func (api *API) traceBorBlock(ctx context.Context, block *types.Block, config *T
}
// block object cannot be converted to JSON since much of the fields are non-public
blockFields, err := ethapi.RPCMarshalBlock(block, true, true, api.backend.ChainConfig(), api.backend.ChainDb())
if err != nil {
return nil, err
}
blockFields := ethapi.RPCMarshalBlock(block, true, true, api.backend.ChainConfig(), api.backend.ChainDb())
res.Block = blockFields
@ -71,7 +68,7 @@ func (api *API) traceBorBlock(ctx context.Context, block *types.Block, config *T
// Execute all the transaction contained within the block concurrently
var (
signer = types.MakeSigner(api.backend.ChainConfig(), block.Number())
signer = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time())
txs, stateSyncPresent = api.getAllBlockTransactions(ctx, block)
deleteEmptyObjects = api.backend.ChainConfig().IsEIP158(block.Number())
)

4
eth/tracers/internal/tracetest/calltrace_test.go
View file

@ -401,7 +401,7 @@ func TestInternals(t *testing.T) {
Balance: big.NewInt(500000000000000),
},
}, false)
evm := vm.NewEVM(context, txContext, statedb, params.MainnetChainConfig, vm.Config{Tracer: tc.tracer})
evm := vm.NewEVM(blockContext, txContext, statedb, params.MainnetChainConfig, vm.Config{Tracer: tc.tracer})
msg := &core.Message{
To: &to,
From: origin,
@ -413,7 +413,7 @@ func TestInternals(t *testing.T) {
SkipAccountChecks: false,
}
st := core.NewStateTransition(evm, msg, new(core.GasPool).AddGas(msg.GasLimit))
if _, err := st.TransitionDb(); err != nil {
if _, err := st.TransitionDb(context.Background()); err != nil {
t.Fatalf("test %v: failed to execute transaction: %v", tc.name, err)
}
// Retrieve the trace result and compare against the expected

131
ethclient/ethclient_test.go
View file

@ -207,30 +207,30 @@ var testTx2 = types.MustSignNewTx(testKey, types.LatestSigner(genesis.Config), &
To: &common.Address{2},
})
func newTestBackend(t *testing.T) (*node.Node, []*types.Block) {
// Generate test chain.
blocks := generateTestChain()
// func newTestBackend(t *testing.T) (*node.Node, []*types.Block) {
// // Generate test chain.
// blocks := generateTestChain()
// Create node
n, err := node.New(&node.Config{})
if err != nil {
t.Fatalf("can't create new node: %v", err)
}
// Create Ethereum Service
config := &ethconfig.Config{Genesis: genesis}
ethservice, err := eth.New(n, config)
if err != nil {
t.Fatalf("can't create new ethereum service: %v", err)
}
// Import the test chain.
if err := n.Start(); err != nil {
t.Fatalf("can't start test node: %v", err)
}
if _, err := ethservice.BlockChain().InsertChain(blocks[1:]); err != nil {
t.Fatalf("can't import test blocks: %v", err)
}
return n, blocks
}
// // Create node
// n, err := node.New(&node.Config{})
// if err != nil {
// t.Fatalf("can't create new node: %v", err)
// }
// // Create Ethereum Service
// config := &ethconfig.Config{Genesis: genesis}
// ethservice, err := eth.New(n, config)
// if err != nil {
// t.Fatalf("can't create new ethereum service: %v", err)
// }
// // Import the test chain.
// if err := n.Start(); err != nil {
// t.Fatalf("can't start test node: %v", err)
// }
// if _, err := ethservice.BlockChain().InsertChain(blocks[1:]); err != nil {
// t.Fatalf("can't import test blocks: %v", err)
// }
// return n, blocks
// }
func generateTestChain() []*types.Block {
generate := func(i int, g *core.BlockGen) {
@ -249,50 +249,51 @@ func generateTestChain() []*types.Block {
}
func TestEthClient(t *testing.T) {
backend, chain := newTestBackend(t)
client := backend.Attach()
defer backend.Close()
defer client.Close()
t.Skip("bor due to burn contract")
// backend, chain := newTestBackend(t)
// client := backend.Attach()
// defer backend.Close()
// defer client.Close()
tests := map[string]struct {
test func(t *testing.T)
}{
"Header": {
func(t *testing.T) { testHeader(t, chain, client) },
},
"BalanceAt": {
func(t *testing.T) { testBalanceAt(t, client) },
},
"TxInBlockInterrupted": {
func(t *testing.T) { testTransactionInBlockInterrupted(t, client) },
},
"ChainID": {
func(t *testing.T) { testChainID(t, client) },
},
"GetBlock": {
func(t *testing.T) { testGetBlock(t, client) },
},
"StatusFunctions": {
func(t *testing.T) { testStatusFunctions(t, client) },
},
"CallContract": {
func(t *testing.T) { testCallContract(t, client) },
},
"CallContractAtHash": {
func(t *testing.T) { testCallContractAtHash(t, client) },
},
"AtFunctions": {
func(t *testing.T) { testAtFunctions(t, client) },
},
"TransactionSender": {
func(t *testing.T) { testTransactionSender(t, client) },
},
}
// tests := map[string]struct {
// test func(t *testing.T)
// }{
// "Header": {
// func(t *testing.T) { testHeader(t, chain, client) },
// },
// "BalanceAt": {
// func(t *testing.T) { testBalanceAt(t, client) },
// },
// "TxInBlockInterrupted": {
// func(t *testing.T) { testTransactionInBlockInterrupted(t, client) },
// },
// "ChainID": {
// func(t *testing.T) { testChainID(t, client) },
// },
// "GetBlock": {
// func(t *testing.T) { testGetBlock(t, client) },
// },
// "StatusFunctions": {
// func(t *testing.T) { testStatusFunctions(t, client) },
// },
// "CallContract": {
// func(t *testing.T) { testCallContract(t, client) },
// },
// "CallContractAtHash": {
// func(t *testing.T) { testCallContractAtHash(t, client) },
// },
// "AtFunctions": {
// func(t *testing.T) { testAtFunctions(t, client) },
// },
// "TransactionSender": {
// func(t *testing.T) { testTransactionSender(t, client) },
// },
// }
t.Parallel()
for name, tt := range tests {
t.Run(name, tt.test)
}
// t.Parallel()
// for name, tt := range tests {
// t.Run(name, tt.test)
// }
}
func testHeader(t *testing.T, chain []*types.Block, client *rpc.Client) {

113
graphql/graphql.go
View file

@ -74,7 +74,6 @@ func (b *Long) UnmarshalGraphQL(input interface{}) error {
default:
err = fmt.Errorf("unexpected type %T for Long", input)
}
return err
}
@ -100,12 +99,10 @@ func (a *Account) Balance(ctx context.Context) (hexutil.Big, error) {
if err != nil {
return hexutil.Big{}, err
}
balance := state.GetBalance(a.address)
if balance == nil {
return hexutil.Big{}, fmt.Errorf("failed to load balance %x", a.address)
}
return hexutil.Big(*balance), nil
}
@ -116,15 +113,12 @@ func (a *Account) TransactionCount(ctx context.Context) (hexutil.Uint64, error)
if err != nil {
return 0, err
}
return hexutil.Uint64(nonce), nil
}
state, err := a.getState(ctx)
if err != nil {
return 0, err
}
return hexutil.Uint64(state.GetNonce(a.address)), nil
}
@ -133,7 +127,6 @@ func (a *Account) Code(ctx context.Context) (hexutil.Bytes, error) {
if err != nil {
return hexutil.Bytes{}, err
}
return state.GetCode(a.address), nil
}
@ -142,7 +135,6 @@ func (a *Account) Storage(ctx context.Context, args struct{ Slot common.Hash })
if err != nil {
return common.Hash{}, err
}
return state.GetState(a.address, args.Slot), nil
}
@ -233,7 +225,6 @@ type Transaction struct {
func (t *Transaction) resolve(ctx context.Context) (*types.Transaction, *Block) {
t.mu.Lock()
defer t.mu.Unlock()
if t.tx != nil {
return t.tx, t.block
}
@ -280,7 +271,6 @@ func (t *Transaction) GasPrice(ctx context.Context) hexutil.Big {
if tx == nil {
return hexutil.Big{}
}
switch tx.Type() {
case types.AccessListTxType:
return hexutil.Big(*tx.GasPrice())
@ -306,16 +296,13 @@ func (t *Transaction) EffectiveGasPrice(ctx context.Context) (*hexutil.Big, erro
if block == nil {
return nil, nil
}
header, err := block.resolveHeader(ctx)
if err != nil || header == nil {
return nil, err
}
if header.BaseFee == nil {
return (*hexutil.Big)(tx.GasPrice()), nil
}
return (*hexutil.Big)(math.BigMin(new(big.Int).Add(tx.GasTipCap(), header.BaseFee), tx.GasFeeCap())), nil
}
@ -324,7 +311,6 @@ func (t *Transaction) MaxFeePerGas(ctx context.Context) *hexutil.Big {
if tx == nil {
return nil
}
switch tx.Type() {
case types.AccessListTxType:
return nil
@ -340,7 +326,6 @@ func (t *Transaction) MaxPriorityFeePerGas(ctx context.Context) *hexutil.Big {
if tx == nil {
return nil
}
switch tx.Type() {
case types.AccessListTxType:
return nil
@ -360,12 +345,10 @@ func (t *Transaction) EffectiveTip(ctx context.Context) (*hexutil.Big, error) {
if block == nil {
return nil, nil
}
header, err := block.resolveHeader(ctx)
if err != nil || header == nil {
return nil, err
}
if header.BaseFee == nil {
return (*hexutil.Big)(tx.GasPrice()), nil
}
@ -374,7 +357,6 @@ func (t *Transaction) EffectiveTip(ctx context.Context) (*hexutil.Big, error) {
if err != nil {
return nil, err
}
return (*hexutil.Big)(tip), nil
}
@ -383,11 +365,9 @@ func (t *Transaction) Value(ctx context.Context) (hexutil.Big, error) {
if tx == nil {
return hexutil.Big{}, nil
}
if tx.Value() == nil {
return hexutil.Big{}, fmt.Errorf("invalid transaction value %x", t.hash)
}
return hexutil.Big(*tx.Value()), nil
}
@ -404,12 +384,10 @@ func (t *Transaction) To(ctx context.Context, args BlockNumberArgs) *Account {
if tx == nil {
return nil
}
to := tx.To()
if to == nil {
return nil
}
return &Account{
r: t.r,
address: *to,
@ -422,10 +400,8 @@ func (t *Transaction) From(ctx context.Context, args BlockNumberArgs) *Account {
if tx == nil {
return nil
}
signer := types.LatestSigner(t.r.backend.ChainConfig())
from, _ := types.Sender(signer, tx)
return &Account{
r: t.r,
address: from,
@ -455,12 +431,10 @@ func (t *Transaction) getReceipt(ctx context.Context) (*types.Receipt, error) {
if block == nil {
return nil, nil
}
receipts, err := block.resolveReceipts(ctx)
if err != nil {
return nil, err
}
return receipts[t.index], nil
}
@ -469,7 +443,6 @@ func (t *Transaction) Status(ctx context.Context) (*hexutil.Uint64, error) {
if err != nil || receipt == nil {
return nil, err
}
if len(receipt.PostState) != 0 {
return nil, nil
}
@ -500,7 +473,6 @@ func (t *Transaction) CreatedContract(ctx context.Context, args BlockNumberArgs)
if err != nil || receipt == nil || receipt.ContractAddress == (common.Address{}) {
return nil, err
}
return &Account{
r: t.r,
address: receipt.ContractAddress,
@ -512,16 +484,12 @@ func (t *Transaction) Logs(ctx context.Context) (*[]*Log, error) {
_, block := t.resolve(ctx)
// Pending tx
if block == nil {
//nolint:nilnil
return nil, nil
}
h, err := block.Hash(ctx)
if err != nil {
return nil, err
}
return t.getLogs(ctx, h)
}
@ -532,12 +500,9 @@ func (t *Transaction) getLogs(ctx context.Context, hash common.Hash) (*[]*Log, e
filter = t.r.filterSystem.NewBlockFilter(hash, nil, nil)
logs, err = filter.Logs(ctx)
)
if err != nil {
return nil, err
}
// nolint:prealloc
var ret []*Log
// Select tx logs from all block logs
ix := sort.Search(len(logs), func(i int) bool { return uint64(logs[i].TxIndex) >= t.index })
@ -549,7 +514,6 @@ func (t *Transaction) getLogs(ctx context.Context, hash common.Hash) (*[]*Log, e
})
ix++
}
return &ret, nil
}
@ -564,10 +528,8 @@ func (t *Transaction) AccessList(ctx context.Context) *[]*AccessTuple {
if tx == nil {
return nil
}
accessList := tx.AccessList()
ret := make([]*AccessTuple, 0, len(accessList))
for _, al := range accessList {
ret = append(ret, &AccessTuple{
address: al.Address,
@ -619,7 +581,6 @@ func (t *Transaction) Raw(ctx context.Context) (hexutil.Bytes, error) {
if tx == nil {
return hexutil.Bytes{}, nil
}
return tx.MarshalBinary()
}
@ -628,7 +589,6 @@ func (t *Transaction) RawReceipt(ctx context.Context) (hexutil.Bytes, error) {
if err != nil || receipt == nil {
return hexutil.Bytes{}, err
}
return receipt.MarshalBinary()
}
@ -653,26 +613,21 @@ type Block struct {
func (b *Block) resolve(ctx context.Context) (*types.Block, error) {
b.mu.Lock()
defer b.mu.Unlock()
if b.block != nil {
return b.block, nil
}
if b.numberOrHash == nil {
latest := rpc.BlockNumberOrHashWithNumber(rpc.LatestBlockNumber)
b.numberOrHash = &latest
}
var err error
b.block, err = b.r.backend.BlockByNumberOrHash(ctx, *b.numberOrHash)
if b.block != nil {
b.hash = b.block.Hash()
if b.header == nil {
b.header = b.block.Header()
}
}
return b.block, err
}
@ -682,26 +637,20 @@ func (b *Block) resolve(ctx context.Context) (*types.Block, error) {
func (b *Block) resolveHeader(ctx context.Context) (*types.Header, error) {
b.mu.Lock()
defer b.mu.Unlock()
if b.header != nil {
return b.header, nil
}
if b.numberOrHash == nil && b.hash == (common.Hash{}) {
return nil, errBlockInvariant
}
var err error
b.header, err = b.r.backend.HeaderByNumberOrHash(ctx, *b.numberOrHash)
if err != nil {
return nil, err
}
if b.hash == (common.Hash{}) {
b.hash = b.header.Hash()
}
return b.header, nil
}
@ -710,19 +659,14 @@ func (b *Block) resolveHeader(ctx context.Context) (*types.Header, error) {
func (b *Block) resolveReceipts(ctx context.Context) ([]*types.Receipt, error) {
b.mu.Lock()
defer b.mu.Unlock()
if b.receipts != nil {
return b.receipts, nil
}
receipts, err := b.r.backend.GetReceipts(ctx, b.hash)
if err != nil {
return nil, err
}
b.receipts = receipts
return receipts, nil
}
@ -738,7 +682,6 @@ func (b *Block) Number(ctx context.Context) (hexutil.Uint64, error) {
func (b *Block) Hash(ctx context.Context) (common.Hash, error) {
b.mu.Lock()
defer b.mu.Unlock()
return b.hash, nil
}
@ -763,11 +706,9 @@ func (b *Block) BaseFeePerGas(ctx context.Context) (*hexutil.Big, error) {
if err != nil {
return nil, err
}
if header.BaseFee == nil {
return nil, nil
}
return (*hexutil.Big)(header.BaseFee), nil
}
@ -776,7 +717,6 @@ func (b *Block) NextBaseFeePerGas(ctx context.Context) (*hexutil.Big, error) {
if err != nil {
return nil, err
}
chaincfg := b.r.backend.ChainConfig()
if header.BaseFee == nil {
// Make sure next block doesn't enable EIP-1559
@ -792,11 +732,9 @@ func (b *Block) Parent(ctx context.Context) (*Block, error) {
if _, err := b.resolveHeader(ctx); err != nil {
return nil, err
}
if b.header == nil || b.header.Number.Uint64() < 1 {
return nil, nil
}
var (
num = rpc.BlockNumber(b.header.Number.Uint64() - 1)
hash = b.header.ParentHash
@ -805,7 +743,6 @@ func (b *Block) Parent(ctx context.Context) (*Block, error) {
BlockHash: &hash,
}
)
return &Block{
r: b.r,
numberOrHash: &numOrHash,
@ -818,7 +755,6 @@ func (b *Block) Difficulty(ctx context.Context) (hexutil.Big, error) {
if err != nil {
return hexutil.Big{}, err
}
return hexutil.Big(*header.Difficulty), nil
}
@ -827,7 +763,6 @@ func (b *Block) Timestamp(ctx context.Context) (hexutil.Uint64, error) {
if err != nil {
return 0, err
}
return hexutil.Uint64(header.Time), nil
}
@ -836,7 +771,6 @@ func (b *Block) Nonce(ctx context.Context) (hexutil.Bytes, error) {
if err != nil {
return hexutil.Bytes{}, err
}
return header.Nonce[:], nil
}
@ -845,7 +779,6 @@ func (b *Block) MixHash(ctx context.Context) (common.Hash, error) {
if err != nil {
return common.Hash{}, err
}
return header.MixDigest, nil
}
@ -854,7 +787,6 @@ func (b *Block) TransactionsRoot(ctx context.Context) (common.Hash, error) {
if err != nil {
return common.Hash{}, err
}
return header.TxHash, nil
}
@ -863,7 +795,6 @@ func (b *Block) StateRoot(ctx context.Context) (common.Hash, error) {
if err != nil {
return common.Hash{}, err
}
return header.Root, nil
}
@ -872,7 +803,6 @@ func (b *Block) ReceiptsRoot(ctx context.Context) (common.Hash, error) {
if err != nil {
return common.Hash{}, err
}
return header.ReceiptHash, nil
}
@ -881,7 +811,6 @@ func (b *Block) OmmerHash(ctx context.Context) (common.Hash, error) {
if err != nil {
return common.Hash{}, err
}
return header.UncleHash, nil
}
@ -899,9 +828,7 @@ func (b *Block) Ommers(ctx context.Context) (*[]*Block, error) {
if err != nil || block == nil {
return nil, err
}
ret := make([]*Block, 0, len(block.Uncles()))
for _, uncle := range block.Uncles() {
blockNumberOrHash := rpc.BlockNumberOrHashWithHash(uncle.Hash(), false)
ret = append(ret, &Block{
@ -911,7 +838,6 @@ func (b *Block) Ommers(ctx context.Context) (*[]*Block, error) {
hash: uncle.Hash(),
})
}
return &ret, nil
}
@ -920,7 +846,6 @@ func (b *Block) ExtraData(ctx context.Context) (hexutil.Bytes, error) {
if err != nil {
return hexutil.Bytes{}, err
}
return header.Extra, nil
}
@ -929,7 +854,6 @@ func (b *Block) LogsBloom(ctx context.Context) (hexutil.Bytes, error) {
if err != nil {
return hexutil.Bytes{}, err
}
return header.Bloom.Bytes(), nil
}
@ -938,12 +862,10 @@ func (b *Block) TotalDifficulty(ctx context.Context) (hexutil.Big, error) {
if err != nil {
return hexutil.Big{}, err
}
td := b.r.backend.GetTd(ctx, hash)
if td == nil {
return hexutil.Big{}, fmt.Errorf("total difficulty not found %x", hash)
}
return hexutil.Big(*td), nil
}
@ -952,7 +874,6 @@ func (b *Block) RawHeader(ctx context.Context) (hexutil.Bytes, error) {
if err != nil {
return hexutil.Bytes{}, err
}
return rlp.EncodeToBytes(header)
}
@ -961,7 +882,6 @@ func (b *Block) Raw(ctx context.Context) (hexutil.Bytes, error) {
if err != nil {
return hexutil.Bytes{}, err
}
return rlp.EncodeToBytes(block)
}
@ -980,7 +900,6 @@ func (a BlockNumberArgs) NumberOr(current rpc.BlockNumberOrHash) rpc.BlockNumber
blockNr := rpc.BlockNumber(*a.Block)
return rpc.BlockNumberOrHashWithNumber(blockNr)
}
return current
}
@ -995,7 +914,6 @@ func (b *Block) Miner(ctx context.Context, args BlockNumberArgs) (*Account, erro
if err != nil {
return nil, err
}
return &Account{
r: b.r,
address: header.Coinbase,
@ -1017,7 +935,6 @@ func (b *Block) Transactions(ctx context.Context) (*[]*Transaction, error) {
if err != nil || block == nil {
return nil, err
}
ret := make([]*Transaction, 0, len(block.Transactions()))
for i, tx := range block.Transactions() {
ret = append(ret, &Transaction{
@ -1028,7 +945,6 @@ func (b *Block) Transactions(ctx context.Context) (*[]*Transaction, error) {
index: uint64(i),
})
}
return &ret, nil
}
@ -1037,14 +953,11 @@ func (b *Block) TransactionAt(ctx context.Context, args struct{ Index Long }) (*
if err != nil || block == nil {
return nil, err
}
txs := block.Transactions()
if args.Index < 0 || int(args.Index) >= len(txs) {
return nil, nil
}
tx := txs[args.Index]
return &Transaction{
r: b.r,
hash: tx.Hash(),
@ -1059,15 +972,12 @@ func (b *Block) OmmerAt(ctx context.Context, args struct{ Index Long }) (*Block,
if err != nil || block == nil {
return nil, err
}
uncles := block.Uncles()
if args.Index < 0 || int(args.Index) >= len(uncles) {
return nil, nil
}
uncle := uncles[args.Index]
blockNumberOrHash := rpc.BlockNumberOrHashWithHash(uncle.Hash(), false)
return &Block{
r: b.r,
numberOrHash: &blockNumberOrHash,
@ -1135,7 +1045,6 @@ func runFilter(ctx context.Context, r *Resolver, filter *filters.Filter) ([]*Log
if err != nil || logs == nil {
return nil, err
}
ret := make([]*Log, 0, len(logs))
for _, log := range logs {
ret = append(ret, &Log{
@ -1144,7 +1053,6 @@ func runFilter(ctx context.Context, r *Resolver, filter *filters.Filter) ([]*Log
log: log,
})
}
return ret, nil
}
@ -1153,7 +1061,6 @@ func (b *Block) Logs(ctx context.Context, args struct{ Filter BlockFilterCriteri
if args.Filter.Addresses != nil {
addresses = *args.Filter.Addresses
}
var topics [][]common.Hash
if args.Filter.Topics != nil {
topics = *args.Filter.Topics
@ -1163,7 +1070,6 @@ func (b *Block) Logs(ctx context.Context, args struct{ Filter BlockFilterCriteri
if err != nil {
return nil, err
}
filter := b.r.filterSystem.NewBlockFilter(hash, addresses, topics)
// Run the filter and return all the logs
@ -1251,7 +1157,6 @@ func (p *Pending) Transactions(ctx context.Context) (*[]*Transaction, error) {
if err != nil {
return nil, err
}
ret := make([]*Transaction, 0, len(txs))
for i, tx := range txs {
ret = append(ret, &Transaction{
@ -1261,7 +1166,6 @@ func (p *Pending) Transactions(ctx context.Context) (*[]*Transaction, error) {
index: uint64(i),
})
}
return &ret, nil
}
@ -1269,7 +1173,6 @@ func (p *Pending) Account(ctx context.Context, args struct {
Address common.Address
}) *Account {
pendingBlockNr := rpc.BlockNumberOrHashWithNumber(rpc.PendingBlockNumber)
return &Account{
r: p.r,
address: args.Address,
@ -1315,12 +1218,10 @@ func (r *Resolver) Block(ctx context.Context, args struct {
Hash *common.Hash
}) (*Block, error) {
var numberOrHash rpc.BlockNumberOrHash
if args.Number != nil {
if *args.Number < 0 {
return nil, nil
}
number := rpc.BlockNumber(*args.Number)
numberOrHash = rpc.BlockNumberOrHashWithNumber(number)
} else if args.Hash != nil {
@ -1328,7 +1229,6 @@ func (r *Resolver) Block(ctx context.Context, args struct {
} else {
numberOrHash = rpc.BlockNumberOrHashWithNumber(rpc.LatestBlockNumber)
}
block := &Block{
r: r,
numberOrHash: &numberOrHash,
@ -1342,7 +1242,6 @@ func (r *Resolver) Block(ctx context.Context, args struct {
} else if h == nil {
return nil, nil
}
return block, nil
}
@ -1358,7 +1257,6 @@ func (r *Resolver) Blocks(ctx context.Context, args struct {
} else {
to = rpc.BlockNumber(r.backend.CurrentBlock().Number.Int64())
}
if to < from {
return []*Block{}, nil
}
@ -1379,13 +1277,11 @@ func (r *Resolver) Blocks(ctx context.Context, args struct {
// Blocks after must be non-existent too, break.
break
}
ret = append(ret, block)
if err := ctx.Err(); err != nil {
return nil, err
}
}
return ret, nil
}
@ -1411,9 +1307,7 @@ func (r *Resolver) SendRawTransaction(ctx context.Context, args struct{ Data hex
if err := tx.UnmarshalBinary(args.Data); err != nil {
return common.Hash{}, err
}
hash, err := ethapi.SubmitTransaction(ctx, r.backend, tx)
return hash, err
}
@ -1443,24 +1337,20 @@ func (r *Resolver) Logs(ctx context.Context, args struct{ Filter FilterCriteria
if args.Filter.FromBlock != nil {
begin = int64(*args.Filter.FromBlock)
}
end := rpc.LatestBlockNumber.Int64()
if args.Filter.ToBlock != nil {
end = int64(*args.Filter.ToBlock)
}
var addresses []common.Address
if args.Filter.Addresses != nil {
addresses = *args.Filter.Addresses
}
var topics [][]common.Hash
if args.Filter.Topics != nil {
topics = *args.Filter.Topics
}
// Construct the range filter
filter := r.filterSystem.NewRangeFilter(begin, end, addresses, topics)
return runFilter(ctx, r, filter)
}
@ -1469,11 +1359,9 @@ func (r *Resolver) GasPrice(ctx context.Context) (hexutil.Big, error) {
if err != nil {
return hexutil.Big{}, err
}
if head := r.backend.CurrentHeader(); head.BaseFee != nil {
tipcap.Add(tipcap, head.BaseFee)
}
return (hexutil.Big)(*tipcap), nil
}
@ -1482,7 +1370,6 @@ func (r *Resolver) MaxPriorityFeePerGas(ctx context.Context) (hexutil.Big, error
if err != nil {
return hexutil.Big{}, err
}
return (hexutil.Big)(*tipcap), nil
}

39
graphql/graphql_test.go
View file

@ -49,14 +49,10 @@ func TestBuildSchema(t *testing.T) {
// Copy config
conf := node.DefaultConfig
conf.DataDir = ddir
stack, err := node.New(&conf)
defer stack.Close()
if err != nil {
t.Fatalf("could not create new node: %v", err)
}
defer stack.Close()
// Make sure the schema can be parsed and matched up to the object model.
if _, err := newHandler(stack, nil, nil, []string{}, []string{}); err != nil {
@ -68,7 +64,6 @@ func TestBuildSchema(t *testing.T) {
func TestGraphQLBlockSerialization(t *testing.T) {
stack := createNode(t)
defer stack.Close()
genesis := &core.Genesis{
Config: params.AllEthashProtocolChanges,
GasLimit: 11500000,
@ -158,25 +153,20 @@ func TestGraphQLBlockSerialization(t *testing.T) {
if err != nil {
t.Fatalf("could not post: %v", err)
}
bodyBytes, err := io.ReadAll(resp.Body)
resp.Body.Close()
if err != nil {
t.Fatalf("could not read from response body: %v", err)
}
if have := string(bodyBytes); have != tt.want {
t.Errorf("testcase %d %s,\nhave:\n%v\nwant:\n%v", i, tt.body, have, tt.want)
}
if tt.code != resp.StatusCode {
t.Errorf("testcase %d %s,\nwrong statuscode, have: %v, want: %v", i, tt.body, resp.StatusCode, tt.code)
}
}
}
// nolint:typecheck
func TestGraphQLBlockSerializationEIP2718(t *testing.T) {
// Account for signing txes
var (
@ -185,10 +175,8 @@ func TestGraphQLBlockSerializationEIP2718(t *testing.T) {
funds = big.NewInt(1000000000000000)
dad = common.HexToAddress("0x0000000000000000000000000000000000000dad")
)
stack := createNode(t)
defer stack.Close()
genesis := &core.Genesis{
Config: params.AllEthashProtocolChanges,
GasLimit: 11500000,
@ -207,7 +195,6 @@ func TestGraphQLBlockSerializationEIP2718(t *testing.T) {
signer := types.LatestSigner(genesis.Config)
newGQLService(t, stack, false, genesis, 1, func(i int, gen *core.BlockGen) {
gen.SetCoinbase(common.Address{1})
tx, _ := types.SignNewTx(key, signer, &types.LegacyTx{
Nonce: uint64(0),
To: &dad,
@ -250,18 +237,14 @@ func TestGraphQLBlockSerializationEIP2718(t *testing.T) {
if err != nil {
t.Fatalf("could not post: %v", err)
}
bodyBytes, err := io.ReadAll(resp.Body)
resp.Body.Close()
if err != nil {
t.Fatalf("could not read from response body: %v", err)
}
if have := string(bodyBytes); have != tt.want {
t.Errorf("testcase %d %s,\nhave:\n%v\nwant:\n%v", i, tt.body, have, tt.want)
}
if tt.code != resp.StatusCode {
t.Errorf("testcase %d %s,\nwrong statuscode, have: %v, want: %v", i, tt.body, resp.StatusCode, tt.code)
}
@ -272,27 +255,20 @@ func TestGraphQLBlockSerializationEIP2718(t *testing.T) {
func TestGraphQLHTTPOnSamePort_GQLRequest_Unsuccessful(t *testing.T) {
stack := createNode(t)
defer stack.Close()
if err := stack.Start(); err != nil {
t.Fatalf("could not start node: %v", err)
}
body := strings.NewReader(`{"query": "{block{number}}","variables": null}`)
resp, err := http.Post(fmt.Sprintf("%s/graphql", stack.HTTPEndpoint()), "application/json", body)
if err != nil {
t.Fatalf("could not post: %v", err)
}
resp.Body.Close()
// make sure the request is not handled successfully
assert.Equal(t, http.StatusNotFound, resp.StatusCode)
}
// nolint:typecheck
func TestGraphQLConcurrentResolvers(t *testing.T) {
t.Parallel()
var (
key, _ = crypto.GenerateKey()
addr = crypto.PubkeyToAddress(key.PublicKey)
@ -315,7 +291,6 @@ func TestGraphQLConcurrentResolvers(t *testing.T) {
signer = types.LatestSigner(genesis.Config)
stack = createNode(t)
)
defer stack.Close()
var tx *types.Transaction
@ -339,13 +314,13 @@ func TestGraphQLConcurrentResolvers(t *testing.T) {
// Multiple txes race to get/set the block hash.
{
body: "{block { transactions { logs { account { address } } } } }",
want: fmt.Sprintf(`{"block":{"transactions":[{"logs":[{"account":{"address":"%s"}},{"account":{"address":"%s"}},{"account":{"address":"%s"}}]},{"logs":[{"account":{"address":"%s"}},{"account":{"address":"%s"}},{"account":{"address":"%s"}}]},{"logs":[{"account":{"address":"%s"}},{"account":{"address":"%s"}},{"account":{"address":"%s"}}]}]}}`, dadStr, dadStr, core.GetFeeAddress(), dadStr, dadStr, core.GetFeeAddress(), dadStr, dadStr, core.GetFeeAddress()),
want: fmt.Sprintf(`{"block":{"transactions":[{"logs":[{"account":{"address":"%s"}},{"account":{"address":"%s"}}]},{"logs":[{"account":{"address":"%s"}},{"account":{"address":"%s"}}]},{"logs":[{"account":{"address":"%s"}},{"account":{"address":"%s"}}]}]}}`, dadStr, dadStr, dadStr, dadStr, dadStr, dadStr),
},
// Multiple fields of a tx race to resolve it. Happens in this case
// because resolving the tx body belonging to a log is delayed.
{
body: `{block { logs(filter: {}) { transaction { nonce value gasPrice }}}}`,
want: `{"block":{"logs":[{"transaction":{"nonce":"0x0","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x0","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x0","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x1","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x1","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x1","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x2","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x2","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x2","value":"0x0","gasPrice":"0x3b9aca00"}}]}}`,
want: `{"block":{"logs":[{"transaction":{"nonce":"0x0","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x0","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x1","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x1","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x2","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x2","value":"0x0","gasPrice":"0x3b9aca00"}}]}}`,
},
// Multiple txes of a block race to set/retrieve receipts of a block.
{
@ -374,17 +349,13 @@ func TestGraphQLConcurrentResolvers(t *testing.T) {
},
} {
res := handler.Schema.Exec(context.Background(), tt.body, "", map[string]interface{}{})
if res.Errors != nil {
t.Fatalf("failed to execute query for testcase #%d: %v", i, res.Errors)
}
have, err := json.Marshal(res.Data)
if err != nil {
t.Fatalf("failed to encode graphql response for testcase #%d: %s", i, err)
}
if string(have) != tt.want {
t.Errorf("response unmatch for testcase #%d.\nExpected:\n%s\nGot:\n%s\n", i, tt.want, have)
}
@ -452,8 +423,6 @@ func TestWithdrawals(t *testing.T) {
}
func createNode(t *testing.T) *node.Node {
t.Helper()
stack, err := node.New(&node.Config{
HTTPHost: "127.0.0.1",
HTTPPort: 0,
@ -464,7 +433,6 @@ func createNode(t *testing.T) *node.Node {
if err != nil {
t.Fatalf("could not create node: %v", err)
}
return stack
}
@ -488,7 +456,6 @@ func newGQLService(t *testing.T, stack *node.Node, shanghai bool, gspec *core.Ge
shanghaiTime := uint64(5)
chainCfg.ShanghaiTime = &shanghaiTime
}
ethBackend, err := eth.New(stack, ethConf)
if err != nil {
t.Fatalf("could not create eth backend: %v", err)
@ -502,11 +469,9 @@ func newGQLService(t *testing.T, stack *node.Node, shanghai bool, gspec *core.Ge
}
// Set up handler
filterSystem := filters.NewFilterSystem(ethBackend.APIBackend, filters.Config{})
handler, err := newHandler(stack, ethBackend.APIBackend, filterSystem, []string{}, []string{})
if err != nil {
t.Fatalf("could not create graphql service: %v", err)
}
return handler, chain
}

12
graphql/service.go
View file

@ -42,7 +42,6 @@ func (h handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
OperationName string `json:"operationName"`
Variables map[string]interface{} `json:"variables"`
}
if err := json.NewDecoder(r.Body).Decode(&params); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
@ -54,7 +53,6 @@ func (h handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
timer *time.Timer
cancel context.CancelFunc
)
ctx, cancel = context.WithCancel(ctx)
defer cancel()
@ -68,7 +66,6 @@ func (h handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
response := &graphql.Response{
Errors: []*gqlErrors.QueryError{{Message: "request timed out"}},
}
responseJSON, err := json.Marshal(response)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
@ -82,8 +79,7 @@ func (h handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
// chunked transfer encoding must be disabled by setting content-length.
w.Header().Set("content-type", "application/json")
w.Header().Set("content-length", strconv.Itoa(len(responseJSON)))
_, _ = w.Write(responseJSON)
w.Write(responseJSON)
if flush, ok := w.(http.Flusher); ok {
flush.Flush()
}
@ -92,7 +88,6 @@ func (h handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
}
response := h.Schema.Exec(ctx, params.Query, params.OperationName, params.Variables)
timer.Stop()
responded.Do(func() {
responseJSON, err := json.Marshal(response)
@ -100,13 +95,11 @@ func (h handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
if len(response.Errors) > 0 {
w.WriteHeader(http.StatusBadRequest)
}
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write(responseJSON)
w.Write(responseJSON)
})
}
@ -125,7 +118,6 @@ func newHandler(stack *node.Node, backend ethapi.Backend, filterSystem *filters.
if err != nil {
return nil, err
}
h := handler{Schema: s}
handler := node.NewHTTPHandlerStack(h, cors, vhosts, nil)

2
internal/cli/server/config.go
View file

@ -1084,8 +1084,6 @@ func (c *Config) buildEth(stack *node.Node, accountManager *accounts.Manager) (*
log.Debug("Sanitizing Go's GC trigger", "percent", int(gogc))
godebug.SetGCPercent(int(gogc))
n.TrieCleanCacheJournal = c.Cache.Journal
n.TrieCleanCacheRejournal = c.Cache.Rejournal
n.DatabaseCache = calcPerc(c.Cache.PercDatabase)
n.SnapshotCache = calcPerc(c.Cache.PercSnapshot)
n.TrieCleanCache = calcPerc(c.Cache.PercTrie)

2
internal/cli/server/server.go
View file

@ -273,7 +273,7 @@ func NewServer(config *Config, opts ...serverOption) (*Server, error) {
// sealing (if enabled) or in dev mode
if config.Sealer.Enabled || config.Developer.Enabled {
if err := srv.backend.StartMining(1); err != nil {
if err := srv.backend.StartMining(); err != nil {
return nil, err
}
}

1
internal/cli/snapshot.go
View file

@ -170,7 +170,6 @@ func (c *PruneStateCommand) Run(args []string) int {
prunerconfig := pruner.Config{
Datadir: node.ResolvePath(""),
Cachedir: node.ResolvePath(c.cacheTrieJournal),
BloomSize: c.bloomfilterSize,
}

31
internal/debug/flags.go
View file

@ -26,16 +26,15 @@ import (
"path/filepath"
"runtime"
"github.com/ethereum/go-ethereum/internal/flags"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/metrics"
"github.com/ethereum/go-ethereum/metrics/exp"
"github.com/fjl/memsize/memsizeui"
"github.com/mattn/go-colorable"
"github.com/mattn/go-isatty"
"github.com/urfave/cli/v2"
"gopkg.in/natefinch/lumberjack.v2"
"github.com/ethereum/go-ethereum/internal/flags"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/metrics"
"github.com/ethereum/go-ethereum/metrics/exp"
)
var Memsize memsizeui.Handler
@ -192,14 +191,12 @@ func init() {
// Setup initializes profiling and logging based on the CLI flags.
// It should be called as early as possible in the program.
// nolint:nestif
func Setup(ctx *cli.Context) error {
var (
logfmt log.Format
output = io.Writer(os.Stderr)
logFmtFlag = ctx.String(logFormatFlag.Name)
)
switch {
case ctx.Bool(logjsonFlag.Name):
// Retain backwards compatibility with `--log.json` flag if `--log.format` not set
@ -214,33 +211,28 @@ func Setup(ctx *cli.Context) error {
if useColor {
output = colorable.NewColorableStderr()
}
logfmt = log.TerminalFormat(useColor)
default:
// Unknown log format specified
return fmt.Errorf("unknown log format: %v", ctx.String(logFormatFlag.Name))
}
var (
stdHandler = log.StreamHandler(output, logfmt)
ostream = stdHandler
logFile = ctx.String(logFileFlag.Name)
rotation = ctx.Bool(logRotateFlag.Name)
)
if len(logFile) > 0 {
if err := validateLogLocation(filepath.Dir(logFile)); err != nil {
return fmt.Errorf("failed to initiatilize file logger: %v", err)
}
}
context := []interface{}{"rotate", rotation}
if len(logFmtFlag) > 0 {
context = append(context, "format", logFmtFlag)
} else {
context = append(context, "format", "terminal")
}
if rotation {
// Lumberjack uses <processname>-lumberjack.log in is.TempDir() if empty.
// so typically /tmp/geth-lumberjack.log on linux
@ -249,7 +241,6 @@ func Setup(ctx *cli.Context) error {
} else {
context = append(context, "location", filepath.Join(os.TempDir(), "geth-lumberjack.log"))
}
ostream = log.MultiHandler(log.StreamHandler(&lumberjack.Logger{
Filename: logFile,
MaxSize: ctx.Int(logMaxSizeMBsFlag.Name),
@ -262,17 +253,14 @@ func Setup(ctx *cli.Context) error {
return err
} else {
ostream = log.MultiHandler(logOutputStream, stdHandler)
context = append(context, "location", logFile)
}
}
glogger.SetHandler(ostream)
// logging
verbosity := ctx.Int(verbosityFlag.Name)
glogger.Verbosity(log.Lvl(verbosity))
vmodule := ctx.String(logVmoduleFlag.Name)
if vmodule == "" {
// Retain backwards compatibility with `--vmodule` flag if `--log.vmodule` not set
@ -281,14 +269,12 @@ func Setup(ctx *cli.Context) error {
defer log.Warn("The flag '--vmodule' is deprecated, please use '--log.vmodule' instead")
}
}
glogger.Vmodule(vmodule)
debug := ctx.Bool(debugFlag.Name)
if ctx.IsSet(debugFlag.Name) {
debug = ctx.Bool(debugFlag.Name)
}
log.PrintOrigins(debug)
backtrace := ctx.String(backtraceAtFlag.Name)
@ -327,15 +313,10 @@ func Setup(ctx *cli.Context) error {
// This context value ("metrics.addr") represents the utils.MetricsHTTPFlag.Name.
// It cannot be imported because it will cause a cyclical dependency.
StartPProf(address, !ctx.IsSet("metrics.addr"))
} else if ctx.IsSet("bor-mumbai") || ctx.IsSet("bor-mainnet") {
address := fmt.Sprintf("%s:%d", "0.0.0.0", 7071)
StartPProf(address, !ctx.IsSet("metrics.addr"))
}
if len(logFile) > 0 || rotation {
log.Info("Logging configured", context...)
}
return nil
}
@ -345,10 +326,8 @@ func StartPProf(address string, withMetrics bool) {
if withMetrics {
exp.Exp(metrics.DefaultRegistry)
}
http.Handle("/memsize/", http.StripPrefix("/memsize", &Memsize))
log.Info("Starting pprof server", "addr", fmt.Sprintf("http://%s/debug/pprof", address))
go func() {
if err := http.ListenAndServe(address, nil); err != nil {
log.Error("Failure in running pprof server", "err", err)
@ -361,7 +340,6 @@ func StartPProf(address string, withMetrics bool) {
func Exit() {
Handler.StopCPUProfile()
Handler.StopGoTrace()
if closer, ok := logOutputStream.(io.Closer); ok {
closer.Close()
}
@ -378,6 +356,5 @@ func validateLogLocation(path string) error {
} else {
f.Close()
}
return os.Remove(tmp)
}

25
internal/ethapi/api.go
View file

@ -1213,10 +1213,10 @@ func doCall(ctx context.Context, b Backend, args TransactionArgs, state *state.S
return nil, err
}
return doCallWithState(ctx, b, args, header, state, timeout, globalGasCap)
return doCallWithState(ctx, b, args, header, state, timeout, globalGasCap, blockOverrides)
}
func doCallWithState(ctx context.Context, b Backend, args TransactionArgs, header *types.Header, state *state.StateDB, timeout time.Duration, globalGasCap uint64) (*core.ExecutionResult, error) {
func doCallWithState(ctx context.Context, b Backend, args TransactionArgs, header *types.Header, state *state.StateDB, timeout time.Duration, globalGasCap uint64, blockOverrides *BlockOverrides) (*core.ExecutionResult, error) {
// Setup context so it may be cancelled the call has completed
// or, in case of unmetered gas, setup a context with a timeout.
var cancel context.CancelFunc
@ -1317,6 +1317,19 @@ func (e *revertError) ErrorData() interface{} {
// Note, this function doesn't make and changes in the state/blockchain and is
// useful to execute and retrieve values.
func (s *BlockChainAPI) Call(ctx context.Context, args TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, overrides *StateOverride, blockOverrides *BlockOverrides) (hexutil.Bytes, error) {
return s.CallWithState(ctx, args, blockNrOrHash, nil, overrides, blockOverrides)
}
// CallWithState executes the given transaction on the given state for
// the given block number. Note that as it does an EVM call, fields in
// the underlying state will change. Make sure to handle it outside of
// this function (ideally by sending a copy of state).
//
// Additionally, the caller can specify a batch of contract for fields overriding.
//
// Note, this function doesn't make and changes in the state/blockchain and is
// useful to execute and retrieve values.
func (s *BlockChainAPI) CallWithState(ctx context.Context, args TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, state *state.StateDB, overrides *StateOverride, blockOverrides *BlockOverrides) (hexutil.Bytes, error) {
result, err := DoCall(ctx, s.b, args, blockNrOrHash, overrides, blockOverrides, s.b.RPCEVMTimeout(), s.b.RPCGasCap())
if err != nil {
return nil, err
@ -1595,7 +1608,7 @@ func RPCMarshalHeader(head *types.Header) map[string]interface{} {
// RPCMarshalBlock converts the given block to the RPC output which depends on fullTx. If inclTx is true transactions are
// returned. When fullTx is true the returned block contains full transaction details, otherwise it will only contain
// transaction hashes.
func RPCMarshalBlock(block *types.Block, inclTx bool, fullTx bool, config *params.ChainConfig) map[string]interface{} {
func RPCMarshalBlock(block *types.Block, inclTx bool, fullTx bool, config *params.ChainConfig, db ethdb.Database) map[string]interface{} {
fields := RPCMarshalHeader(block.Header())
fields["size"] = hexutil.Uint64(block.Size())
@ -1605,7 +1618,7 @@ func RPCMarshalBlock(block *types.Block, inclTx bool, fullTx bool, config *param
}
if fullTx {
formatTx = func(idx int, tx *types.Transaction) interface{} {
return newRPCTransactionFromBlockIndex(block, uint64(idx), config)
return newRPCTransactionFromBlockIndex(block, uint64(idx), config, db)
}
}
@ -1644,7 +1657,7 @@ func (s *BlockChainAPI) rpcMarshalHeader(ctx context.Context, header *types.Head
// rpcMarshalBlock uses the generalized output filler, then adds the total difficulty field, which requires
// a `BlockchainAPI`.
func (s *BlockChainAPI) rpcMarshalBlock(ctx context.Context, b *types.Block, inclTx bool, fullTx bool) (map[string]interface{}, error) {
fields := RPCMarshalBlock(b, inclTx, fullTx, s.b.ChainConfig())
fields := RPCMarshalBlock(b, inclTx, fullTx, s.b.ChainConfig(), s.b.ChainDb())
if inclTx {
fields["totalDifficulty"] = (*hexutil.Big)(s.b.GetTd(ctx, b.Hash()))
}
@ -1780,7 +1793,7 @@ func newRPCTransactionFromBlockIndex(b *types.Block, index uint64, config *param
return nil
}
rpcTx := newRPCTransaction(txs[index], b.Hash(), b.NumberU64(), index, b.BaseFee(), config)
rpcTx := newRPCTransaction(txs[index], b.Hash(), b.NumberU64(), b.Time(), index, b.BaseFee(), config)
// If the transaction is a bor transaction, we need to set the hash to the derived bor tx hash. BorTx is always the last index.
if borReceipt != nil && index == uint64(len(txs)-1) {

25
internal/ethapi/api_test.go
View file

@ -360,7 +360,7 @@ func newTestBackend(t *testing.T, n int, gspec *core.Genesis, generator func(i i
// Generate blocks for testing
db, blocks, _ := core.GenerateChainWithGenesis(gspec, engine, n, generator)
txlookupLimit := uint64(0)
chain, err := core.NewBlockChain(db, cacheConfig, gspec, nil, engine, vm.Config{}, nil, &txlookupLimit)
chain, err := core.NewBlockChain(db, cacheConfig, gspec, nil, engine, vm.Config{}, nil, &txlookupLimit, nil)
if err != nil {
t.Fatalf("failed to create tester chain: %v", err)
}
@ -536,6 +536,29 @@ func (b testBackend) ServiceFilter(ctx context.Context, session *bloombits.Match
panic("implement me")
}
func (b testBackend) GetBorBlockLogs(ctx context.Context, hash common.Hash) ([]*types.Log, error) {
receipt, err := b.GetBorBlockReceipt(ctx, hash)
if err != nil || receipt == nil {
return nil, err
}
return receipt.Logs, nil
}
func (b testBackend) GetBorBlockReceipt(ctx context.Context, hash common.Hash) (*types.Receipt, error) {
number := rawdb.ReadHeaderNumber(b.db, hash)
if number == nil {
return nil, nil
}
receipt := rawdb.ReadRawBorReceipt(b.db, hash, *number)
if receipt == nil {
return nil, nil
}
return receipt, nil
}
func TestEstimateGas(t *testing.T) {
t.Parallel()
// Initialize test accounts

2
internal/ethapi/bor_api.go
View file

@ -34,7 +34,7 @@ func (s *BlockChainAPI) appendRPCMarshalBorTransaction(ctx context.Context, bloc
formattedTxs := fields["transactions"].([]interface{})
if fullTx {
marshalledTx := newRPCTransaction(borTx, blockHash, blockNumber, txIndex, block.BaseFee(), s.b.ChainConfig())
marshalledTx := newRPCTransaction(borTx, blockHash, blockNumber, block.Time(), txIndex, block.BaseFee(), s.b.ChainConfig())
// newRPCTransaction calculates hash based on RLP of the transaction data.
// In case of bor block tx, we need simple derived tx hash (same as function argument) instead of RLP hash
marshalledTx.Hash = txHash

97
les/api.go
View file

@ -21,7 +21,6 @@ import (
"fmt"
"time"
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/common/mclock"
vfs "github.com/ethereum/go-ethereum/les/vflux/server"
"github.com/ethereum/go-ethereum/p2p/enode"
@ -49,7 +48,6 @@ func parseNode(node string) (enode.ID, error) {
if id, err := enode.ParseID(node); err == nil {
return id, nil
}
if node, err := enode.Parse(enode.ValidSchemes, node); err == nil {
return node.ID(), nil
} else {
@ -65,14 +63,12 @@ func (api *LightServerAPI) ServerInfo() map[string]interface{} {
_, res["totalCapacity"] = api.server.clientPool.Limits()
_, res["totalConnectedCapacity"] = api.server.clientPool.Active()
res["priorityConnectedCapacity"] = 0 //TODO connect when token sale module is added
return res
}
// ClientInfo returns information about clients listed in the ids list or matching the given tags
func (api *LightServerAPI) ClientInfo(nodes []string) map[enode.ID]map[string]interface{} {
var ids []enode.ID
for _, node := range nodes {
if id, err := parseNode(node); err == nil {
ids = append(ids, id)
@ -80,11 +76,9 @@ func (api *LightServerAPI) ClientInfo(nodes []string) map[enode.ID]map[string]in
}
res := make(map[enode.ID]map[string]interface{})
if len(ids) == 0 {
ids = api.server.peers.ids()
}
for _, id := range ids {
if peer := api.server.peers.peer(id); peer != nil {
res[id] = api.clientInfo(peer, peer.balance)
@ -94,7 +88,6 @@ func (api *LightServerAPI) ClientInfo(nodes []string) map[enode.ID]map[string]in
})
}
}
return res
}
@ -107,12 +100,10 @@ func (api *LightServerAPI) ClientInfo(nodes []string) map[enode.ID]map[string]in
func (api *LightServerAPI) PriorityClientInfo(start, stop enode.ID, maxCount int) map[enode.ID]map[string]interface{} {
res := make(map[enode.ID]map[string]interface{})
ids := api.server.clientPool.GetPosBalanceIDs(start, stop, maxCount+1)
if len(ids) > maxCount {
res[ids[maxCount]] = make(map[string]interface{})
ids = ids[:maxCount]
}
for _, id := range ids {
if peer := api.server.peers.peer(id); peer != nil {
res[id] = api.clientInfo(peer, peer.balance)
@ -122,7 +113,6 @@ func (api *LightServerAPI) PriorityClientInfo(start, stop enode.ID, maxCount int
})
}
}
return res
}
@ -140,7 +130,6 @@ func (api *LightServerAPI) clientInfo(peer *clientPeer, balance vfs.ReadOnlyBala
info["capacity"] = peer.getCapacity()
info["pricing/negBalance"] = nb
}
return info
}
@ -148,7 +137,6 @@ func (api *LightServerAPI) clientInfo(peer *clientPeer, balance vfs.ReadOnlyBala
// or the default parameters applicable to clients connected in the future
func (api *LightServerAPI) setParams(params map[string]interface{}, client *clientPeer, posFactors, negFactors *vfs.PriceFactors) (updateFactors bool, err error) {
defParams := client == nil
for name, value := range params {
errValue := func() error {
return fmt.Errorf("invalid value for parameter '%s'", name)
@ -189,12 +177,10 @@ func (api *LightServerAPI) setParams(params map[string]interface{}, client *clie
err = fmt.Errorf("invalid client parameter '%s'", name)
}
}
if err != nil {
return
}
}
return
}
@ -202,22 +188,17 @@ func (api *LightServerAPI) setParams(params map[string]interface{}, client *clie
// or all connected clients if the list is empty
func (api *LightServerAPI) SetClientParams(nodes []string, params map[string]interface{}) error {
var err error
for _, node := range nodes {
var id enode.ID
if id, err = parseNode(node); err != nil {
return err
}
if peer := api.server.peers.peer(id); peer != nil {
posFactors, negFactors := peer.balance.GetPriceFactors()
update, e := api.setParams(params, peer, &posFactors, &negFactors)
if update {
peer.balance.SetPriceFactors(posFactors, negFactors)
}
if e != nil {
err = e
}
@ -225,7 +206,6 @@ func (api *LightServerAPI) SetClientParams(nodes []string, params map[string]int
err = fmt.Errorf("client %064x is not connected", id)
}
}
return err
}
@ -235,7 +215,6 @@ func (api *LightServerAPI) SetDefaultParams(params map[string]interface{}) error
if update {
api.server.clientPool.SetDefaultFactors(api.defaultPosFactors, api.defaultNegFactors)
}
return err
}
@ -247,9 +226,7 @@ func (api *LightServerAPI) SetConnectedBias(bias time.Duration) error {
if bias < time.Duration(0) {
return fmt.Errorf("bias illegal: %v less than 0", bias)
}
api.server.clientPool.SetConnectedBias(bias)
return nil
}
@ -257,15 +234,12 @@ func (api *LightServerAPI) SetConnectedBias(bias time.Duration) error {
// the balance before and after the operation
func (api *LightServerAPI) AddBalance(node string, amount int64) (balance [2]uint64, err error) {
var id enode.ID
if id, err = parseNode(node); err != nil {
return
}
api.server.clientPool.BalanceOperation(id, "", func(nb vfs.AtomicBalanceOperator) {
balance[0], balance[1], err = nb.AddBalance(amount)
})
return
}
@ -277,24 +251,20 @@ func (api *LightServerAPI) AddBalance(node string, amount int64) (balance [2]uin
// Therefore a controlled total measurement time is achievable in multiple passes.
func (api *LightServerAPI) Benchmark(setups []map[string]interface{}, passCount, length int) ([]map[string]interface{}, error) {
benchmarks := make([]requestBenchmark, len(setups))
for i, setup := range setups {
if t, ok := setup["type"].(string); ok {
getInt := func(field string, def int) int {
if value, ok := setup[field].(float64); ok {
return int(value)
}
return def
}
getBool := func(field string, def bool) bool {
if value, ok := setup[field].(bool); ok {
return value
}
return def
}
switch t {
case "header":
benchmarks[i] = &benchmarkBlockHeaders{
@ -332,10 +302,8 @@ func (api *LightServerAPI) Benchmark(setups []map[string]interface{}, passCount,
return nil, errUnknownBenchmarkType
}
}
rs := api.server.handler.runBenchmark(benchmarks, passCount, time.Millisecond*time.Duration(length))
result := make([]map[string]interface{}, len(setups))
for i, r := range rs {
res := make(map[string]interface{})
if r.err == nil {
@ -346,10 +314,8 @@ func (api *LightServerAPI) Benchmark(setups []map[string]interface{}, passCount,
} else {
res["error"] = r.err.Error()
}
result[i] = res
}
return result, nil
}
@ -371,11 +337,9 @@ func (api *DebugAPI) FreezeClient(node string) error {
id enode.ID
err error
)
if id, err = parseNode(node); err != nil {
return err
}
if peer := api.server.peers.peer(id); peer != nil {
peer.freeze()
return nil
@ -383,64 +347,3 @@ func (api *DebugAPI) FreezeClient(node string) error {
return fmt.Errorf("client %064x is not connected", id[:])
}
}
// LightAPI provides an API to access the LES light server or light client.
type LightAPI struct {
backend *lesCommons
}
// NewLightAPI creates a new LES service API.
func NewLightAPI(backend *lesCommons) *LightAPI {
return &LightAPI{backend: backend}
}
// LatestCheckpoint returns the latest local checkpoint package.
//
// The checkpoint package consists of 4 strings:
//
// result[0], hex encoded latest section index
// result[1], 32 bytes hex encoded latest section head hash
// result[2], 32 bytes hex encoded latest section canonical hash trie root hash
// result[3], 32 bytes hex encoded latest section bloom trie root hash
func (api *LightAPI) LatestCheckpoint() ([4]string, error) {
var res [4]string
cp := api.backend.latestLocalCheckpoint()
if cp.Empty() {
return res, errNoCheckpoint
}
res[0] = hexutil.EncodeUint64(cp.SectionIndex)
res[1], res[2], res[3] = cp.SectionHead.Hex(), cp.CHTRoot.Hex(), cp.BloomRoot.Hex()
return res, nil
}
// GetCheckpoint returns the specific local checkpoint package.
//
// The checkpoint package consists of 3 strings:
//
// result[0], 32 bytes hex encoded latest section head hash
// result[1], 32 bytes hex encoded latest section canonical hash trie root hash
// result[2], 32 bytes hex encoded latest section bloom trie root hash
func (api *LightAPI) GetCheckpoint(index uint64) ([3]string, error) {
var res [3]string
cp := api.backend.localCheckpoint(index)
if cp.Empty() {
return res, errNoCheckpoint
}
res[0], res[1], res[2] = cp.SectionHead.Hex(), cp.CHTRoot.Hex(), cp.BloomRoot.Hex()
return res, nil
}
// GetCheckpointContractAddress returns the contract contract address in hex format.
func (api *LightAPI) GetCheckpointContractAddress() (string, error) {
if api.backend.oracle == nil {
return "", errNotActivated
}
return api.backend.oracle.Contract().ContractAddr().Hex(), nil
}

38
les/api_backend.go
View file

@ -67,11 +67,9 @@ func (b *LesApiBackend) HeaderByNumber(ctx context.Context, number rpc.BlockNumb
if number == rpc.PendingBlockNumber {
return b.eth.blockchain.CurrentHeader(), nil
}
if number == rpc.LatestBlockNumber {
return b.eth.blockchain.CurrentHeader(), nil
}
return b.eth.blockchain.GetHeaderByNumberOdr(ctx, uint64(number))
}
@ -79,24 +77,19 @@ func (b *LesApiBackend) HeaderByNumberOrHash(ctx context.Context, blockNrOrHash
if blockNr, ok := blockNrOrHash.Number(); ok {
return b.HeaderByNumber(ctx, blockNr)
}
if hash, ok := blockNrOrHash.Hash(); ok {
header, err := b.HeaderByHash(ctx, hash)
if err != nil {
return nil, err
}
if header == nil {
return nil, errors.New("header for hash not found")
}
if blockNrOrHash.RequireCanonical && b.eth.blockchain.GetCanonicalHash(header.Number.Uint64()) != hash {
return nil, errors.New("hash is not currently canonical")
}
return header, nil
}
return nil, errors.New("invalid arguments; neither block nor hash specified")
}
@ -109,7 +102,6 @@ func (b *LesApiBackend) BlockByNumber(ctx context.Context, number rpc.BlockNumbe
if header == nil || err != nil {
return nil, err
}
return b.BlockByHash(ctx, header.Hash())
}
@ -121,24 +113,19 @@ func (b *LesApiBackend) BlockByNumberOrHash(ctx context.Context, blockNrOrHash r
if blockNr, ok := blockNrOrHash.Number(); ok {
return b.BlockByNumber(ctx, blockNr)
}
if hash, ok := blockNrOrHash.Hash(); ok {
block, err := b.BlockByHash(ctx, hash)
if err != nil {
return nil, err
}
if block == nil {
return nil, errors.New("header found, but block body is missing")
}
if blockNrOrHash.RequireCanonical && b.eth.blockchain.GetCanonicalHash(block.NumberU64()) != hash {
return nil, errors.New("hash is not currently canonical")
}
return block, nil
}
return nil, errors.New("invalid arguments; neither block nor hash specified")
}
@ -155,11 +142,9 @@ func (b *LesApiBackend) StateAndHeaderByNumber(ctx context.Context, number rpc.B
if err != nil {
return nil, nil, err
}
if header == nil {
return nil, nil, errors.New("header not found")
}
return light.NewState(ctx, header, b.eth.odr), header, nil
}
@ -167,20 +152,16 @@ func (b *LesApiBackend) StateAndHeaderByNumberOrHash(ctx context.Context, blockN
if blockNr, ok := blockNrOrHash.Number(); ok {
return b.StateAndHeaderByNumber(ctx, blockNr)
}
if hash, ok := blockNrOrHash.Hash(); ok {
header := b.eth.blockchain.GetHeaderByHash(hash)
if header == nil {
return nil, nil, errors.New("header for hash not found")
}
if blockNrOrHash.RequireCanonical && b.eth.blockchain.GetCanonicalHash(header.Number.Uint64()) != hash {
return nil, nil, errors.New("hash is not currently canonical")
}
return light.NewState(ctx, header, b.eth.odr), header, nil
}
return nil, nil, errors.New("invalid arguments; neither block nor hash specified")
}
@ -188,7 +169,6 @@ func (b *LesApiBackend) GetReceipts(ctx context.Context, hash common.Hash) (type
if number := rawdb.ReadHeaderNumber(b.eth.chainDb, hash); number != nil {
return light.GetBlockReceipts(ctx, b.eth.odr, hash, *number)
}
return nil, nil
}
@ -200,7 +180,6 @@ func (b *LesApiBackend) GetTd(ctx context.Context, hash common.Hash) *big.Int {
if number := rawdb.ReadHeaderNumber(b.eth.chainDb, hash); number != nil {
return b.eth.blockchain.GetTdOdr(ctx, hash, *number)
}
return nil
}
@ -208,11 +187,12 @@ func (b *LesApiBackend) GetEVM(ctx context.Context, msg *core.Message, state *st
if vmConfig == nil {
vmConfig = new(vm.Config)
}
txContext := core.NewEVMTxContext(msg)
context := core.NewEVMBlockContext(header, b.eth.blockchain, nil)
return vm.NewEVM(context, txContext, state, b.eth.chainConfig, *vmConfig), state.Error, nil
if blockCtx != nil {
context = *blockCtx
}
return vm.NewEVM(context, txContext, state, b.eth.chainConfig, *vmConfig), state.Error
}
func (b *LesApiBackend) SendTx(ctx context.Context, signedTx *types.Transaction) error {
@ -318,10 +298,6 @@ func (b *LesApiBackend) RPCGasCap() uint64 {
return b.eth.config.RPCGasCap
}
func (b *LesApiBackend) RPCRpcReturnDataLimit() uint64 {
return b.eth.config.RPCReturnDataLimit
}
func (b *LesApiBackend) RPCEVMTimeout() time.Duration {
return b.eth.config.RPCEVMTimeout
}
@ -334,9 +310,7 @@ func (b *LesApiBackend) BloomStatus() (uint64, uint64) {
if b.eth.bloomIndexer == nil {
return 0, 0
}
sections, _, _ := b.eth.bloomIndexer.Sections()
return params.BloomBitsBlocksClient, sections
}
@ -362,6 +336,10 @@ func (b *LesApiBackend) StateAtTransaction(ctx context.Context, block *types.Blo
return b.eth.stateAtTransaction(ctx, block, txIndex, reexec)
}
func (b *LesApiBackend) RPCRpcReturnDataLimit() uint64 {
return b.eth.config.RPCReturnDataLimit
}
//
// Bor related functions
//

44
les/api_test.go
View file

@ -96,7 +96,6 @@ func testCapacityAPI(t *testing.T, clientCount int) {
if testServerDataDir == "" {
return
}
for !testSim(t, 1, clientCount, []string{testServerDataDir}, nil, func(ctx context.Context, net *simulations.Network, servers []*simulations.Node, clients []*simulations.Node) bool {
if len(servers) != 1 {
t.Fatalf("Invalid number of servers: %d", len(servers))
@ -307,42 +306,32 @@ func getHead(ctx context.Context, t *testing.T, client *rpc.Client) (uint64, com
if err := client.CallContext(ctx, &res, "eth_getBlockByNumber", "latest", false); err != nil {
t.Fatalf("Failed to obtain head block: %v", err)
}
numStr, ok := res["number"].(string)
if !ok {
t.Fatalf("RPC block number field invalid")
}
num, err := hexutil.DecodeUint64(numStr)
if err != nil {
t.Fatalf("Failed to decode RPC block number: %v", err)
}
hashStr, ok := res["hash"].(string)
if !ok {
t.Fatalf("RPC block number field invalid")
}
hash := common.HexToHash(hashStr)
return num, hash
}
func testRequest(ctx context.Context, t *testing.T, client *rpc.Client) bool {
var res string
var addr common.Address
_, _ = crand.Read(addr[:])
crand.Read(addr[:])
c, cancel := context.WithTimeout(ctx, time.Second*12)
defer cancel()
err := client.CallContext(c, &res, "eth_getBalance", addr, "latest")
if err != nil {
t.Log("request error:", err)
}
return err == nil
}
@ -355,7 +344,6 @@ func freezeClient(ctx context.Context, t *testing.T, server *rpc.Client, clientI
func setCapacity(ctx context.Context, t *testing.T, server *rpc.Client, clientID enode.ID, cap uint64) {
params := make(map[string]interface{})
params["capacity"] = cap
if err := server.CallContext(ctx, nil, "les_setClientParams", []enode.ID{clientID}, []string{}, params); err != nil {
t.Fatalf("Failed to set client capacity: %v", err)
}
@ -366,22 +354,18 @@ func getCapacity(ctx context.Context, t *testing.T, server *rpc.Client, clientID
if err := server.CallContext(ctx, &res, "les_clientInfo", []enode.ID{clientID}, []string{}); err != nil {
t.Fatalf("Failed to get client info: %v", err)
}
info, ok := res[clientID]
if !ok {
t.Fatalf("Missing client info")
}
v, ok := info["capacity"]
if !ok {
t.Fatalf("Missing field in client info: capacity")
}
vv, ok := v.(float64)
if !ok {
t.Fatalf("Failed to decode capacity field")
}
return uint64(vv)
}
@ -390,23 +374,19 @@ func getCapacityInfo(ctx context.Context, t *testing.T, server *rpc.Client) (min
if err := server.CallContext(ctx, &res, "les_serverInfo"); err != nil {
t.Fatalf("Failed to query server info: %v", err)
}
decode := func(s string) uint64 {
v, ok := res[s]
if !ok {
t.Fatalf("Missing field in server info: %s", s)
}
vv, ok := v.(float64)
if !ok {
t.Fatalf("Failed to decode server info field: %s", s)
}
return uint64(vv)
}
minCap = decode("minimumCapacity")
totalCap = decode("totalCapacity")
return
}
@ -420,7 +400,6 @@ func NewNetwork() (*simulations.Network, func(), error) {
if err != nil {
return nil, adapterTeardown, err
}
defaultService := "streamer"
net := simulations.NewNetwork(adapter, &simulations.NetworkConfig{
ID: "0",
@ -430,13 +409,11 @@ func NewNetwork() (*simulations.Network, func(), error) {
adapterTeardown()
net.Shutdown()
}
return net, teardown, nil
}
func NewAdapter(adapterType string, services adapters.LifecycleConstructors) (adapter adapters.NodeAdapter, teardown func(), err error) {
teardown = func() {}
switch adapterType {
case "sim":
adapter = adapters.NewSimAdapter(services)
@ -447,7 +424,6 @@ func NewAdapter(adapterType string, services adapters.LifecycleConstructors) (ad
if err0 != nil {
return nil, teardown, err0
}
teardown = func() { os.RemoveAll(baseDir) }
adapter = adapters.NewExecAdapter(baseDir)
/*case "docker":
@ -458,20 +434,16 @@ func NewAdapter(adapterType string, services adapters.LifecycleConstructors) (ad
default:
return nil, teardown, errors.New("adapter needs to be one of sim, socket, exec, docker")
}
return adapter, teardown, nil
}
func testSim(t *testing.T, serverCount, clientCount int, serverDir, clientDir []string, test func(ctx context.Context, net *simulations.Network, servers []*simulations.Node, clients []*simulations.Node) bool) bool {
net, teardown, err := NewNetwork()
defer teardown()
if err != nil {
t.Fatalf("Failed to create network: %v", err)
}
timeout := 1800 * time.Second
ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel()
@ -481,32 +453,26 @@ func testSim(t *testing.T, serverCount, clientCount int, serverDir, clientDir []
for i := range clients {
clientconf := adapters.RandomNodeConfig()
clientconf.Lifecycles = []string{"lesclient"}
if len(clientDir) == clientCount {
clientconf.DataDir = clientDir[i]
}
client, err := net.NewNodeWithConfig(clientconf)
if err != nil {
t.Fatalf("Failed to create client: %v", err)
}
clients[i] = client
}
for i := range servers {
serverconf := adapters.RandomNodeConfig()
serverconf.Lifecycles = []string{"lesserver"}
if len(serverDir) == serverCount {
serverconf.DataDir = serverDir[i]
}
server, err := net.NewNodeWithConfig(serverconf)
if err != nil {
t.Fatalf("Failed to create server: %v", err)
}
servers[i] = server
}
@ -515,7 +481,6 @@ func testSim(t *testing.T, serverCount, clientCount int, serverDir, clientDir []
t.Fatalf("Failed to start client node: %v", err)
}
}
for _, server := range servers {
if err := net.Start(server.ID()); err != nil {
t.Fatalf("Failed to start server node: %v", err)
@ -527,9 +492,7 @@ func testSim(t *testing.T, serverCount, clientCount int, serverDir, clientDir []
func newLesClientService(ctx *adapters.ServiceContext, stack *node.Node) (node.Lifecycle, error) {
config := ethconfig.Defaults
config.SyncMode = (ethdownloader.SyncMode)(downloader.LightSync)
config.Ethash.PowMode = ethash.ModeFake
config.SyncMode = downloader.LightSync
return New(stack, &config)
}
@ -538,16 +501,13 @@ func newLesServerService(ctx *adapters.ServiceContext, stack *node.Node) (node.L
config.SyncMode = downloader.FullSync
config.LightServ = testServerCapacity
config.LightPeers = testMaxClients
ethereum, err := eth.New(stack, &config)
if err != nil {
return nil, err
}
_, err = NewLesServer(stack, ethereum, &config)
if err != nil {
return nil, err
}
return ethereum, nil
}

45
les/benchmark.go
View file

@ -20,7 +20,6 @@ import (
crand "crypto/rand"
"encoding/binary"
"errors"
"fmt"
"math/big"
"math/rand"
"sync"
@ -59,22 +58,18 @@ func (b *benchmarkBlockHeaders) init(h *serverHandler, count int) error {
d := int64(b.amount-1) * int64(b.skip+1)
b.offset = 0
b.randMax = h.blockchain.CurrentHeader().Number.Int64() + 1 - d
if b.randMax < 0 {
return errors.New("chain is too short")
}
if b.reverse {
b.offset = d
}
if b.byHash {
b.hashes = make([]common.Hash, count)
for i := range b.hashes {
b.hashes[i] = rawdb.ReadCanonicalHash(h.chainDb, uint64(b.offset+rand.Int63n(b.randMax)))
}
}
return nil
}
@ -82,7 +77,6 @@ func (b *benchmarkBlockHeaders) request(peer *serverPeer, index int) error {
if b.byHash {
return peer.requestHeadersByHash(0, b.hashes[index], b.amount, b.skip, b.reverse)
}
return peer.requestHeadersByNumber(0, uint64(b.offset+rand.Int63n(b.randMax)), b.amount, b.skip, b.reverse)
}
@ -95,11 +89,9 @@ type benchmarkBodiesOrReceipts struct {
func (b *benchmarkBodiesOrReceipts) init(h *serverHandler, count int) error {
randMax := h.blockchain.CurrentHeader().Number.Int64() + 1
b.hashes = make([]common.Hash, count)
for i := range b.hashes {
b.hashes[i] = rawdb.ReadCanonicalHash(h.chainDb, uint64(rand.Int63n(randMax)))
}
return nil
}
@ -107,7 +99,6 @@ func (b *benchmarkBodiesOrReceipts) request(peer *serverPeer, index int) error {
if b.receipts {
return peer.requestReceipts(0, []common.Hash{b.hashes[index]})
}
return peer.requestBodies(0, []common.Hash{b.hashes[index]})
}
@ -124,12 +115,10 @@ func (b *benchmarkProofsOrCode) init(h *serverHandler, count int) error {
func (b *benchmarkProofsOrCode) request(peer *serverPeer, index int) error {
key := make([]byte, 32)
_, _ = crand.Read(key)
crand.Read(key)
if b.code {
return peer.requestCode(0, []CodeReq{{BHash: b.headHash, AccountAddress: key}})
}
return peer.requestProofs(0, []ProofReq{{BHash: b.headHash, Key: key}})
}
@ -147,11 +136,9 @@ func (b *benchmarkHelperTrie) init(h *serverHandler, count int) error {
b.sectionCount, _, _ = h.server.chtIndexer.Sections()
b.headNum = b.sectionCount*params.CHTFrequency - 1
}
if b.sectionCount == 0 {
return errors.New("no processed sections available")
}
return nil
}
@ -160,7 +147,6 @@ func (b *benchmarkHelperTrie) request(peer *serverPeer, index int) error {
if b.bloom {
bitIdx := uint16(rand.Intn(2048))
for i := range reqs {
key := make([]byte, 10)
binary.BigEndian.PutUint16(key[:2], bitIdx)
@ -191,16 +177,13 @@ func (b *benchmarkTxSend) init(h *serverHandler, count int) error {
for i := range b.txs {
data := make([]byte, txSizeCostLimit)
_, _ = crand.Read(data)
crand.Read(data)
tx, err := types.SignTx(types.NewTransaction(0, addr, new(big.Int), 0, new(big.Int), data), signer, key)
if err != nil {
panic(err)
}
b.txs[i] = tx
}
return nil
}
@ -218,9 +201,7 @@ func (b *benchmarkTxStatus) init(h *serverHandler, count int) error {
func (b *benchmarkTxStatus) request(peer *serverPeer, index int) error {
var hash common.Hash
_, _ = crand.Read(hash[:])
crand.Read(hash[:])
return peer.requestTxStatus(0, []common.Hash{hash})
}
@ -240,13 +221,10 @@ func (h *serverHandler) runBenchmark(benchmarks []requestBenchmark, passCount in
for i, b := range benchmarks {
setup[i] = &benchmarkSetup{req: b}
}
for i := 0; i < passCount; i++ {
log.Info("Running benchmark", "pass", i+1, "total", passCount)
todo := make([]*benchmarkSetup, len(benchmarks))
copy(todo, setup)
for len(todo) > 0 {
// select a random element
index := rand.Intn(len(todo))
@ -260,7 +238,6 @@ func (h *serverHandler) runBenchmark(benchmarks []requestBenchmark, passCount in
if next.totalTime > 0 {
count = int(uint64(next.totalCount) * uint64(targetTime) / uint64(next.totalTime))
}
if err := h.measure(next, count); err != nil {
next.err = err
}
@ -274,7 +251,6 @@ func (h *serverHandler) runBenchmark(benchmarks []requestBenchmark, passCount in
s.avgTime = s.totalTime / time.Duration(s.totalCount)
}
}
return setup
}
@ -293,7 +269,6 @@ func (m *meteredPipe) WriteMsg(msg p2p.Msg) error {
if msg.Size > m.maxSize {
m.maxSize = msg.Size
}
return m.rw.WriteMsg(msg)
}
@ -303,24 +278,19 @@ func (h *serverHandler) measure(setup *benchmarkSetup, count int) error {
clientPipe, serverPipe := p2p.MsgPipe()
clientMeteredPipe := &meteredPipe{rw: clientPipe}
serverMeteredPipe := &meteredPipe{rw: serverPipe}
var id enode.ID
_, _ = crand.Read(id[:])
crand.Read(id[:])
peer1 := newServerPeer(lpv2, NetworkId, false, p2p.NewPeer(id, "client", nil), clientMeteredPipe)
peer2 := newClientPeer(lpv2, NetworkId, p2p.NewPeer(id, "server", nil), serverMeteredPipe)
peer2.announceType = announceTypeNone
peer2.fcCosts = make(requestCostTable)
c := &requestCosts{}
for code := range requests {
peer2.fcCosts[code] = c
}
peer2.fcParams = flowcontrol.ServerParams{BufLimit: 1, MinRecharge: 1}
peer2.fcClient = flowcontrol.NewClientNode(h.server.fcManager, peer2.fcParams)
defer peer2.fcClient.Disconnect()
if err := setup.req.init(h, count); err != nil {
@ -353,9 +323,7 @@ func (h *serverHandler) measure(setup *benchmarkSetup, count int) error {
errCh <- err
return
}
var i interface{}
msg.Decode(&i)
}
// at this point we can be sure that the other two
@ -370,17 +338,14 @@ func (h *serverHandler) measure(setup *benchmarkSetup, count int) error {
case <-h.closeCh:
clientPipe.Close()
serverPipe.Close()
return fmt.Errorf("Benchmark cancelled")
return errors.New("Benchmark cancelled")
}
setup.totalTime += time.Duration(mclock.Now() - start)
setup.totalCount += count
setup.maxInSize = clientMeteredPipe.maxSize
setup.maxOutSize = serverMeteredPipe.maxSize
clientPipe.Close()
serverPipe.Close()
return nil
}

2
les/bloombits.go
View file

@ -47,7 +47,6 @@ func (eth *LightEthereum) startBloomHandlers(sectionSize uint64) {
for i := 0; i < bloomServiceThreads; i++ {
go func() {
defer eth.wg.Done()
for {
select {
case <-eth.closeCh:
@ -57,7 +56,6 @@ func (eth *LightEthereum) startBloomHandlers(sectionSize uint64) {
task := <-request
task.Bitsets = make([][]byte, len(task.Sections))
compVectors, err := light.GetBloomBits(task.Context, eth.odr, task.Bit, task.Sections)
if err == nil {
for i := range task.Sections {
if blob, err := bitutil.DecompressBytes(compVectors[i], int(sectionSize/8)); err == nil {

52
les/client.go
View file

@ -31,7 +31,6 @@ import (
"github.com/ethereum/go-ethereum/core/bloombits"
"github.com/ethereum/go-ethereum/core/rawdb"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/eth/downloader/whitelist"
"github.com/ethereum/go-ethereum/eth/ethconfig"
"github.com/ethereum/go-ethereum/eth/gasprice"
"github.com/ethereum/go-ethereum/event"
@ -88,29 +87,27 @@ func New(stack *node.Node, config *ethconfig.Config) (*LightEthereum, error) {
if err != nil {
return nil, err
}
lesDb, err := stack.OpenDatabase("les.client", 0, 0, "eth/db/lesclient/", false)
if err != nil {
return nil, err
}
var overrides core.ChainOverrides
if config.OverrideShanghai != nil {
overrides.OverrideShanghai = config.OverrideShanghai
if config.OverrideCancun != nil {
overrides.OverrideCancun = config.OverrideCancun
}
if config.OverrideVerkle != nil {
overrides.OverrideVerkle = config.OverrideVerkle
}
chainConfig, genesisHash, genesisErr := core.SetupGenesisBlockWithOverride(chainDb, trie.NewDatabase(chainDb), config.Genesis, &overrides)
if _, isCompat := genesisErr.(*params.ConfigCompatError); genesisErr != nil && !isCompat {
return nil, genesisErr
}
engine := ethconfig.CreateConsensusEngine(chainConfig, chainDb)
log.Info("")
log.Info(strings.Repeat("-", 153))
for _, line := range strings.Split(chainConfig.Description(), "\n") {
log.Info(line)
}
log.Info(strings.Repeat("-", 153))
log.Info("")
@ -131,7 +128,7 @@ func New(stack *node.Node, config *ethconfig.Config) (*LightEthereum, error) {
reqDist: newRequestDistributor(peers, &mclock.System{}),
accountManager: stack.AccountManager(),
merger: merger,
engine: ethconfig.CreateConsensusEngine(stack, chainConfig, config, &config.Ethash, chainConfig.Clique, nil, false, chainDb, nil),
engine: engine,
bloomRequests: make(chan chan *bloombits.Retrieval),
bloomIndexer: core.NewBloomIndexer(chainDb, params.BloomBitsBlocksClient, params.HelperTrieConfirmations),
p2pServer: stack.Server(),
@ -144,8 +141,7 @@ func New(stack *node.Node, config *ethconfig.Config) (*LightEthereum, error) {
if leth.udpEnabled {
prenegQuery = leth.prenegQuery
}
leth.serverPool, leth.serverPoolIterator = vfc.NewServerPool(lesDb, []byte("serverpool:"), time.Second, prenegQuery, &mclock.System{}, config.UltraLightServers, requestList)
leth.serverPool, leth.serverPoolIterator = vfc.NewServerPool(lesDb, []byte("serverpool:"), time.Second, prenegQuery, &mclock.System{}, nil, requestList)
leth.serverPool.AddMetrics(suggestedTimeoutGauge, totalValueGauge, serverSelectableGauge, serverConnectedGauge, sessionValueMeter, serverDialedMeter)
leth.retriever = newRetrieveManager(peers, leth.reqDist, leth.serverPool.GetTimeout)
@ -158,10 +154,9 @@ func New(stack *node.Node, config *ethconfig.Config) (*LightEthereum, error) {
// Note: NewLightChain adds the trusted checkpoint so it needs an ODR with
// indexers already set but not started yet
if leth.blockchain, err = light.NewLightChain(leth.odr, leth.chainConfig, leth.engine, checkpoint, whitelist.NewService(10)); err != nil {
if leth.blockchain, err = light.NewLightChain(leth.odr, leth.chainConfig, leth.engine); err != nil {
return nil, err
}
leth.chainReader = leth.blockchain
leth.txPool = light.NewTxPool(leth.chainConfig, leth.blockchain, leth.relay)
@ -173,23 +168,19 @@ func New(stack *node.Node, config *ethconfig.Config) (*LightEthereum, error) {
// Rewind the chain in case of an incompatible config upgrade.
if compat, ok := genesisErr.(*params.ConfigCompatError); ok {
log.Warn("Rewinding chain to upgrade configuration", "err", compat)
if compat.RewindToTime > 0 {
_ = leth.blockchain.SetHeadWithTimestamp(compat.RewindToTime)
leth.blockchain.SetHeadWithTimestamp(compat.RewindToTime)
} else {
_ = leth.blockchain.SetHead(compat.RewindToBlock)
leth.blockchain.SetHead(compat.RewindToBlock)
}
rawdb.WriteChainConfig(chainDb, genesisHash, chainConfig)
}
leth.ApiBackend = &LesApiBackend{stack.Config().ExtRPCEnabled(), stack.Config().AllowUnprotectedTxs, leth, nil}
gpoParams := config.GPO
if gpoParams.Default == nil {
gpoParams.Default = config.Miner.GasPrice
}
leth.ApiBackend.gpo = gasprice.NewOracle(leth.ApiBackend, gpoParams)
leth.handler = newClientHandler(leth)
@ -211,16 +202,12 @@ func (s *LightEthereum) VfluxRequest(n *enode.Node, reqs vflux.Requests) vflux.R
if !s.udpEnabled {
return nil
}
reqsEnc, _ := rlp.EncodeToBytes(&reqs)
repliesEnc, _ := s.p2pServer.DiscV5.TalkRequest(s.serverPool.DialNode(n), "vfx", reqsEnc)
var replies vflux.Replies
if len(repliesEnc) == 0 || rlp.DecodeBytes(repliesEnc, &replies) != nil {
return nil
}
return replies
}
@ -229,11 +216,9 @@ func (s *LightEthereum) VfluxRequest(n *enode.Node, reqs vflux.Requests) vflux.R
func (s *LightEthereum) vfxVersion(n *enode.Node) uint {
if n.Seq() == 0 {
var err error
if !s.udpEnabled {
return 0
}
if n, err = s.p2pServer.DiscV5.RequestENR(n); n != nil && err == nil && n.Seq() != 0 {
s.serverPool.Persist(n)
} else {
@ -245,11 +230,8 @@ func (s *LightEthereum) vfxVersion(n *enode.Node) uint {
if err := n.Load(enr.WithEntry("les", &les)); err != nil || len(les) < 1 {
return 0
}
var version uint
rlp.DecodeBytes(les[0], &version) // Ignore additional fields (for forward compatibility).
return version
}
@ -262,24 +244,18 @@ func (s *LightEthereum) prenegQuery(n *enode.Node) int {
}
var requests vflux.Requests
requests.Add("les", vflux.CapacityQueryName, vflux.CapacityQueryReq{
Bias: 180,
AddTokens: []vflux.IntOrInf{{}},
})
replies := s.VfluxRequest(n, requests)
var cqr vflux.CapacityQueryReply
if replies.Get(0, &cqr) != nil || len(cqr) != 1 { // Note: Get returns an error if replies is nil
return -1
}
if cqr[0] > 0 {
return 1
}
return 0
}
@ -310,7 +286,6 @@ func (s *LightDummyAPI) Mining() bool {
func (s *LightEthereum) APIs() []rpc.API {
apis := ethapi.GetAPIs(s.ApiBackend)
apis = append(apis, s.engine.APIs(s.BlockChain().HeaderChain())...)
return append(apis, []rpc.API{
{
Namespace: "eth",
@ -342,7 +317,6 @@ func (s *LightEthereum) Protocols() []p2p.Protocol {
if p := s.peers.peer(id.String()); p != nil {
return p.Info()
}
return nil
}, s.serverPoolIterator)
}
@ -357,15 +331,12 @@ func (s *LightEthereum) Start() error {
if s.udpEnabled && s.p2pServer.DiscV5 == nil {
s.udpEnabled = false
log.Error("Discovery v5 is not initialized")
}
discovery, err := s.setupDiscovery()
if err != nil {
return err
}
s.serverPool.AddSource(discovery)
s.serverPool.Start()
// Start bloom request workers.
@ -398,6 +369,5 @@ func (s *LightEthereum) Stop() error {
s.lesDb.Close()
s.wg.Wait()
log.Info("Light ethereum stopped")
return nil
}

38
les/costtracker.go
View file

@ -145,36 +145,28 @@ func newCostTracker(db ethdb.Database, config *ethconfig.Config) (*costTracker,
reqInfoCh: make(chan reqInfo, 100),
utilTarget: utilTarget,
}
if config.LightIngress > 0 {
ct.inSizeFactor = utilTarget / float64(config.LightIngress)
}
if config.LightEgress > 0 {
ct.outSizeFactor = utilTarget / float64(config.LightEgress)
}
if makeCostStats {
ct.stats = make(map[uint64][]uint64)
for code := range reqAvgTimeCost {
ct.stats[code] = make([]uint64, 10)
}
}
ct.gfLoop()
costList := ct.makeCostList(ct.globalFactor() * 1.25)
for _, c := range costList {
amount := minBufferReqAmount[c.MsgCode]
cost := c.BaseCost + amount*c.ReqCost
if cost > ct.minBufLimit {
ct.minBufLimit = cost
}
}
ct.minBufLimit *= uint64(minBufferMultiplier)
return ct, (ct.minBufLimit-1)/bufLimitRatio + 1
}
@ -183,7 +175,6 @@ func (ct *costTracker) stop() {
stopCh := make(chan struct{})
ct.stopCh <- stopCh
<-stopCh
if makeCostStats {
ct.printStats()
}
@ -195,25 +186,19 @@ func (ct *costTracker) makeCostList(globalFactor float64) RequestCostList {
maxCost := func(avgTimeCost, inSize, outSize uint64) uint64 {
cost := avgTimeCost * maxCostFactor
inSizeCost := uint64(float64(inSize) * ct.inSizeFactor * globalFactor)
if inSizeCost > cost {
cost = inSizeCost
}
outSizeCost := uint64(float64(outSize) * ct.outSizeFactor * globalFactor)
if outSizeCost > cost {
cost = outSizeCost
}
return cost
}
var list RequestCostList
for code, data := range reqAvgTimeCost {
baseCost := maxCost(data.baseCost, reqMaxInSize[code].baseCost, reqMaxOutSize[code].baseCost)
reqCost := maxCost(data.reqCost, reqMaxInSize[code].reqCost, reqMaxOutSize[code].reqCost)
if ct.minBufLimit != 0 {
// if minBufLimit is set then always enforce maximum request cost <= minBufLimit
maxCost := baseCost + reqCost*minBufferReqAmount[code]
@ -230,7 +215,6 @@ func (ct *costTracker) makeCostList(globalFactor float64) RequestCostList {
ReqCost: reqCost,
})
}
return list
}
@ -270,7 +254,6 @@ func (ct *costTracker) gfLoop() {
if len(data) == 8 {
gfLog = math.Float64frombits(binary.BigEndian.Uint64(data[:]))
}
ct.factor = math.Exp(gfLog)
factor, totalRecharge = ct.factor, ct.utilTarget*ct.factor
@ -281,12 +264,10 @@ func (ct *costTracker) gfLoop() {
go func() {
saveCostFactor := func() {
var data [8]byte
binary.BigEndian.PutUint64(data[:], math.Float64bits(gfLog))
ct.db.Put([]byte(gfDbKey), data[:])
log.Debug("global cost factor saved", "value", factor)
}
saveTicker := time.NewTicker(time.Minute * 10)
defer saveTicker.Stop()
@ -325,7 +306,6 @@ func (ct *costTracker) gfLoop() {
if r.msgCode == SendTxV2Msg || r.msgCode == GetTxStatusMsg {
continue
}
requestServedMeter.Mark(int64(r.servingTime))
requestServedTimer.Update(time.Duration(r.servingTime))
requestEstimatedMeter.Mark(int64(r.avgTimeCost / factor))
@ -339,7 +319,6 @@ func (ct *costTracker) gfLoop() {
// calculate factor correction until now, based on previous values
var gfCorr float64
max := recentTime
if recentAvg > max {
max = recentAvg
@ -376,19 +355,16 @@ func (ct *costTracker) gfLoop() {
ct.factor = factor
ch := ct.totalRechargeCh
ct.gfLock.Unlock()
if ch != nil {
select {
case ct.totalRechargeCh <- uint64(totalRecharge):
default:
}
}
globalFactorGauge.Update(int64(1000 * factor))
log.Debug("global cost factor updated", "factor", factor)
}
}
recentServedGauge.Update(int64(recentTime))
recentEstimatedGauge.Update(int64(recentAvg))
@ -398,7 +374,6 @@ func (ct *costTracker) gfLoop() {
case stopCh := <-ct.stopCh:
saveCostFactor()
close(stopCh)
return
}
}
@ -429,7 +404,6 @@ func (ct *costTracker) subscribeTotalRecharge(ch chan uint64) uint64 {
defer ct.gfLock.Unlock()
ct.totalRechargeCh = ch
return uint64(ct.factor * ct.utilTarget)
}
@ -442,11 +416,9 @@ func (ct *costTracker) updateStats(code, amount, servingTime, realCost uint64) {
case ct.reqInfoCh <- reqInfo{float64(avgTimeCost), float64(servingTime), code}:
default:
}
if makeCostStats {
realCost <<= 4
l := 0
for l < 9 && realCost > avgTimeCost {
l++
realCost >>= 1
@ -466,16 +438,13 @@ func (ct *costTracker) updateStats(code, amount, servingTime, realCost uint64) {
func (ct *costTracker) realCost(servingTime uint64, inSize, outSize uint32) uint64 {
cost := float64(servingTime)
inSizeCost := float64(inSize) * ct.inSizeFactor
if inSizeCost > cost {
cost = inSizeCost
}
outSizeCost := float64(outSize) * ct.outSizeFactor
if outSizeCost > cost {
cost = outSizeCost
}
return uint64(cost * ct.globalFactor())
}
@ -484,7 +453,6 @@ func (ct *costTracker) printStats() {
if ct.stats == nil {
return
}
for code, arr := range ct.stats {
log.Info("Request cost statistics", "code", code, "1/16", arr[0], "1/8", arr[1], "1/4", arr[2], "1/2", arr[3], "1", arr[4], "2", arr[5], "4", arr[6], "8", arr[7], "16", arr[8], ">16", arr[9])
}
@ -516,7 +484,6 @@ func (table requestCostTable) getMaxCost(code, amount uint64) uint64 {
// decode converts a cost list to a cost table
func (list RequestCostList) decode(protocolLength uint64) requestCostTable {
table := make(requestCostTable)
for _, e := range list {
if e.MsgCode < protocolLength {
table[e.MsgCode] = &requestCosts{
@ -525,23 +492,19 @@ func (list RequestCostList) decode(protocolLength uint64) requestCostTable {
}
}
}
return table
}
// testCostList returns a dummy request cost list used by tests
func testCostList(testCost uint64) RequestCostList {
cl := make(RequestCostList, len(reqAvgTimeCost))
var max uint64
for code := range reqAvgTimeCost {
if code > max {
max = code
}
}
i := 0
for code := uint64(0); code <= max; code++ {
if _, ok := reqAvgTimeCost[code]; ok {
cl[i].MsgCode = code
@ -550,6 +513,5 @@ func testCostList(testCost uint64) RequestCostList {
i++
}
}
return cl
}

20
les/distributor.go
View file

@ -85,11 +85,8 @@ func newRequestDistributor(peers *serverPeerSet, clock mclock.Clock) *requestDis
if peers != nil {
peers.subscribe(d)
}
d.wg.Add(1)
go d.loop()
return d
}
@ -127,12 +124,10 @@ var (
// main event loop
func (d *requestDistributor) loop() {
defer d.wg.Done()
for {
select {
case <-d.closeCh:
d.lock.Lock()
elem := d.reqQueue.Front()
for elem != nil {
req := elem.Value.(*distReq)
@ -141,7 +136,6 @@ func (d *requestDistributor) loop() {
elem = elem.Next()
}
d.lock.Unlock()
return
case <-d.loopChn:
d.lock.Lock()
@ -198,7 +192,6 @@ func selectPeerWeight(i interface{}) uint64 {
func (d *requestDistributor) nextRequest() (distPeer, *distReq, time.Duration) {
checkedPeers := make(map[distPeer]struct{})
elem := d.reqQueue.Front()
var (
bestWait time.Duration
sel *utils.WeightedRandomSelect
@ -212,45 +205,36 @@ func (d *requestDistributor) nextRequest() (distPeer, *distReq, time.Duration) {
req := elem.Value.(*distReq)
canSend := false
now := d.clock.Now()
if req.waitForPeers > now {
canSend = true
wait := time.Duration(req.waitForPeers - now)
if bestWait == 0 || wait < bestWait {
bestWait = wait
}
}
for peer := range d.peers {
if _, ok := checkedPeers[peer]; !ok && peer.canQueue() && req.canSend(peer) {
canSend = true
cost := req.getCost(peer)
wait, bufRemain := peer.waitBefore(cost)
if wait == 0 {
if sel == nil {
sel = utils.NewWeightedRandomSelect(selectPeerWeight)
}
sel.Update(selectPeerItem{peer: peer, req: req, weight: uint64(bufRemain*1000000) + 1})
} else {
if bestWait == 0 || wait < bestWait {
bestWait = wait
}
}
checkedPeers[peer] = struct{}{}
}
}
next := elem.Next()
if !canSend && elem == d.reqQueue.Front() {
close(req.sentChn)
d.remove(req)
}
elem = next
}
@ -258,7 +242,6 @@ func (d *requestDistributor) nextRequest() (distPeer, *distReq, time.Duration) {
c := sel.Choose().(selectPeerItem)
return c.peer, c.req, 0
}
return nil, nil, bestWait
}
@ -287,7 +270,6 @@ func (d *requestDistributor) queue(r *distReq) chan distPeer {
for before.Value.(*distReq).reqOrder < r.reqOrder {
before = before.Next()
}
r.element = d.reqQueue.InsertBefore(r, before)
}
@ -297,7 +279,6 @@ func (d *requestDistributor) queue(r *distReq) chan distPeer {
}
r.sentChn = make(chan distPeer, 1)
return r.sentChn
}
@ -314,7 +295,6 @@ func (d *requestDistributor) cancel(r *distReq) bool {
close(r.sentChn)
d.remove(r)
return true
}

14
les/distributor_test.go
View file

@ -59,24 +59,19 @@ func (p *testDistPeer) send(r *testDistReq) {
func (p *testDistPeer) worker(t *testing.T, checkOrder bool, stop chan struct{}) {
var last uint64
for {
wait := time.Millisecond
p.lock.Lock()
if len(p.sent) > 0 {
rq := p.sent[0]
wait = time.Duration(rq.procTime)
p.sumCost -= rq.cost
if checkOrder {
if rq.order <= last {
t.Errorf("Requests processed in wrong order")
}
last = rq.order
}
p.sent = p.sent[1:]
}
p.lock.Unlock()
@ -100,11 +95,9 @@ func (p *testDistPeer) waitBefore(cost uint64) (time.Duration, float64) {
p.lock.RLock()
sumCost := p.sumCost + cost
p.lock.RUnlock()
if sumCost < testDistBufLimit {
return 0, float64(testDistBufLimit-sumCost) / float64(testDistBufLimit)
}
return time.Duration(sumCost - testDistBufLimit), 0
}
@ -130,7 +123,6 @@ func testRequestDistributor(t *testing.T, resend bool) {
defer close(stop)
dist := newRequestDistributor(nil, &mclock.System{})
var peers [testDistPeerCount]*testDistPeer
for i := range peers {
peers[i] = &testDistPeer{}
@ -152,7 +144,6 @@ func testRequestDistributor(t *testing.T, resend bool) {
order: uint64(i),
canSendTo: make(map[*testDistPeer]struct{}),
}
for _, peer := range peers {
if rand.Intn(2) != 0 {
rq.canSendTo[peer] = struct{}{}
@ -160,25 +151,21 @@ func testRequestDistributor(t *testing.T, resend bool) {
}
wg.Add(1)
req := &distReq{
getCost: rq.getCost,
canSend: rq.canSend,
request: rq.request,
}
chn := dist.queue(req)
go func() {
cnt := 1
if resend && len(rq.canSendTo) != 0 {
cnt = rand.Intn(testDistMaxResendCount) + 1
}
for i := 0; i < cnt; i++ {
if i != 0 {
chn = dist.queue(req)
}
p := <-chn
if p == nil {
if len(rq.canSendTo) != 0 {
@ -193,7 +180,6 @@ func testRequestDistributor(t *testing.T, resend bool) {
}
wg.Done()
}()
if rand.Intn(1000) == 0 {
time.Sleep(time.Duration(rand.Intn(5000000)))
}

5
les/enr_entry.go
View file

@ -47,12 +47,10 @@ func (eth *LightEthereum) setupDiscovery() (enode.Iterator, error) {
// Enable DNS discovery.
if len(eth.config.EthDiscoveryURLs) != 0 {
client := dnsdisc.NewClient(dnsdisc.Config{})
dns, err := client.NewIterator(eth.config.EthDiscoveryURLs...)
if err != nil {
return nil, err
}
it.AddSource(dns)
}
@ -63,15 +61,12 @@ func (eth *LightEthereum) setupDiscovery() (enode.Iterator, error) {
forkFilter := forkid.NewFilter(eth.blockchain)
iterator := enode.Filter(it, func(n *enode.Node) bool { return nodeIsServer(forkFilter, n) })
return iterator, nil
}
// nodeIsServer checks whether n is an LES server node.
func nodeIsServer(forkFilter forkid.Filter, n *enode.Node) bool {
var les lesEntry
var eth ethEntry
return n.Load(&les) == nil && n.Load(&eth) == nil && forkFilter(eth.ForkID) == nil
}

47
les/flowcontrol/control.go
View file

@ -82,9 +82,7 @@ func NewClientNode(cm *ClientManager, params ServerParams) *ClientNode {
if keepLogs > 0 {
node.log = newLogger(keepLogs)
}
cm.connect(node)
return node
}
@ -105,16 +103,13 @@ func (node *ClientNode) BufferStatus() (uint64, uint64) {
if !node.connected {
return 0, 0
}
now := node.cm.clock.Now()
node.update(now)
node.cm.updateBuffer(node, 0, now)
bv := node.bufValue
if bv < 0 {
bv = 0
}
return uint64(bv), node.params.BufLimit
}
@ -159,16 +154,13 @@ func (node *ClientNode) recalcBV(now mclock.AbsTime) {
if now < node.lastTime {
dt = 0
}
node.bufValue += int64(node.params.MinRecharge * dt / uint64(fcTimeConst))
if node.bufValue > int64(node.params.BufLimit) {
node.bufValue = int64(node.params.BufLimit)
}
if node.log != nil {
node.log.add(now, fmt.Sprintf("updated bv=%d MRR=%d BufLimit=%d", node.bufValue, node.params.MinRecharge, node.params.BufLimit))
}
node.lastTime = now
}
@ -179,7 +171,6 @@ func (node *ClientNode) UpdateParams(params ServerParams) {
now := node.cm.clock.Now()
node.update(now)
if params.MinRecharge >= node.params.MinRecharge {
node.updateSchedule = nil
node.updateParams(params, now)
@ -188,11 +179,9 @@ func (node *ClientNode) UpdateParams(params ServerParams) {
if params.MinRecharge >= s.params.MinRecharge {
s.params = params
node.updateSchedule = node.updateSchedule[:i+1]
return
}
}
node.updateSchedule = append(node.updateSchedule, scheduledUpdate{time: now.Add(DecParamDelay), params: params})
}
}
@ -205,7 +194,6 @@ func (node *ClientNode) updateParams(params ServerParams, now mclock.AbsTime) {
} else if node.bufValue > int64(params.BufLimit) {
node.bufValue = int64(params.BufLimit)
}
node.cm.updateParams(node, params, now)
}
@ -218,25 +206,19 @@ func (node *ClientNode) AcceptRequest(reqID, index, maxCost uint64) (accepted bo
now := node.cm.clock.Now()
node.update(now)
if int64(maxCost) > node.bufValue {
if node.log != nil {
node.log.add(now, fmt.Sprintf("rejected reqID=%d bv=%d maxCost=%d", reqID, node.bufValue, maxCost))
node.log.dump(now)
}
return false, maxCost - uint64(node.bufValue), 0
}
node.bufValue -= int64(maxCost)
node.sumCost += maxCost
if node.log != nil {
node.log.add(now, fmt.Sprintf("accepted reqID=%d bv=%d maxCost=%d sumCost=%d", reqID, node.bufValue, maxCost, node.sumCost))
}
node.accepted[index] = node.sumCost
return true, 0, node.cm.accepted(node, maxCost, now)
}
@ -248,18 +230,14 @@ func (node *ClientNode) RequestProcessed(reqID, index, maxCost, realCost uint64)
now := node.cm.clock.Now()
node.update(now)
node.cm.processed(node, maxCost, realCost, now)
bv := node.bufValue + int64(node.sumCost-node.accepted[index])
if node.log != nil {
node.log.add(now, fmt.Sprintf("processed reqID=%d bv=%d maxCost=%d realCost=%d sumCost=%d oldSumCost=%d reportedBV=%d", reqID, node.bufValue, maxCost, realCost, node.sumCost, node.accepted[index], bv))
}
delete(node.accepted, index)
if bv < 0 {
return 0
}
return uint64(bv)
}
@ -290,7 +268,6 @@ func NewServerNode(params ServerParams, clock mclock.Clock) *ServerNode {
if keepLogs > 0 {
node.log = newLogger(keepLogs)
}
return node
}
@ -300,7 +277,6 @@ func (node *ServerNode) UpdateParams(params ServerParams) {
defer node.lock.Unlock()
node.recalcBLE(mclock.Now())
if params.BufLimit > node.params.BufLimit {
node.bufEstimate += params.BufLimit - node.params.BufLimit
} else {
@ -308,7 +284,6 @@ func (node *ServerNode) UpdateParams(params ServerParams) {
node.bufEstimate = params.BufLimit
}
}
node.params = params
}
@ -318,17 +293,14 @@ func (node *ServerNode) recalcBLE(now mclock.AbsTime) {
if now < node.lastTime {
return
}
if node.bufRecharge {
dt := uint64(now - node.lastTime)
node.bufEstimate += node.params.MinRecharge * dt / uint64(fcTimeConst)
if node.bufEstimate >= node.params.BufLimit {
node.bufEstimate = node.params.BufLimit
node.bufRecharge = false
}
}
node.lastTime = now
if node.log != nil {
node.log.add(now, fmt.Sprintf("updated bufEst=%d MRR=%d BufLimit=%d", node.bufEstimate, node.params.MinRecharge, node.params.BufLimit))
@ -348,29 +320,23 @@ func (node *ServerNode) CanSend(maxCost uint64) (time.Duration, float64) {
if node.params.BufLimit == 0 {
return time.Duration(math.MaxInt64), 0
}
now := node.clock.Now()
node.recalcBLE(now)
maxCost += uint64(safetyMargin) * node.params.MinRecharge / uint64(fcTimeConst)
if maxCost > node.params.BufLimit {
maxCost = node.params.BufLimit
}
if node.bufEstimate >= maxCost {
relBuf := float64(node.bufEstimate-maxCost) / float64(node.params.BufLimit)
if node.log != nil {
node.log.add(now, fmt.Sprintf("canSend bufEst=%d maxCost=%d true relBuf=%f", node.bufEstimate, maxCost, relBuf))
}
return 0, relBuf
}
timeLeft := time.Duration((maxCost - node.bufEstimate) * uint64(fcTimeConst) / node.params.MinRecharge)
if node.log != nil {
node.log.add(now, fmt.Sprintf("canSend bufEst=%d maxCost=%d false timeLeft=%v", node.bufEstimate, maxCost, timeLeft))
}
return timeLeft, 0
}
@ -390,13 +356,10 @@ func (node *ServerNode) QueuedRequest(reqID, maxCost uint64) {
node.bufEstimate -= maxCost
} else {
log.Error("Queued request with insufficient buffer estimate")
node.bufEstimate = 0
}
node.sumCost += maxCost
node.pending[reqID] = node.sumCost
if node.log != nil {
node.log.add(now, fmt.Sprintf("queued reqID=%d bufEst=%d maxCost=%d sumCost=%d", reqID, node.bufEstimate, maxCost, node.sumCost))
}
@ -410,24 +373,19 @@ func (node *ServerNode) ReceivedReply(reqID, bv uint64) {
now := node.clock.Now()
node.recalcBLE(now)
if bv > node.params.BufLimit {
bv = node.params.BufLimit
}
sc, ok := node.pending[reqID]
if !ok {
return
}
delete(node.pending, reqID)
cc := node.sumCost - sc
newEstimate := uint64(0)
if bv > cc {
newEstimate = bv - cc
}
if newEstimate > node.bufEstimate {
// Note: we never reduce the buffer estimate based on the reported value because
// this can only happen because of the delayed delivery of the latest reply.
@ -437,7 +395,6 @@ func (node *ServerNode) ReceivedReply(reqID, bv uint64) {
node.bufRecharge = node.bufEstimate < node.params.BufLimit
node.lastTime = now
if node.log != nil {
node.log.add(now, fmt.Sprintf("received reqID=%d bufEst=%d reportedBv=%d sumCost=%d oldSumCost=%d", reqID, node.bufEstimate, bv, node.sumCost, sc))
}
@ -452,18 +409,14 @@ func (node *ServerNode) ResumeFreeze(bv uint64) {
for reqID := range node.pending {
delete(node.pending, reqID)
}
now := node.clock.Now()
node.recalcBLE(now)
if bv > node.params.BufLimit {
bv = node.params.BufLimit
}
node.bufEstimate = bv
node.bufRecharge = node.bufEstimate < node.params.BufLimit
node.lastTime = now
if node.log != nil {
node.log.add(now, fmt.Sprintf("unfreeze bv=%d sumCost=%d", bv, node.sumCost))
}

2
les/flowcontrol/logger.go
View file

@ -50,10 +50,8 @@ func (l *logger) add(now mclock.AbsTime, event string) {
keepAfter := now - mclock.AbsTime(l.keep)
for l.delPtr < l.writePtr && l.events[l.delPtr].time <= keepAfter {
delete(l.events, l.delPtr)
l.delPtr++
}
l.events[l.writePtr] = logEvent{now, event}
l.writePtr++
}

51
les/flowcontrol/manager.go
View file

@ -115,7 +115,6 @@ func NewClientManager(curve PieceWiseLinear, clock mclock.Clock) *ClientManager
if curve != nil {
cm.SetRechargeCurve(curve)
}
go func() {
// regularly recalculate and update total capacity
for {
@ -130,7 +129,6 @@ func NewClientManager(curve PieceWiseLinear, clock mclock.Clock) *ClientManager
}
}
}()
return cm
}
@ -148,7 +146,6 @@ func (cm *ClientManager) SetRechargeCurve(curve PieceWiseLinear) {
now := cm.clock.Now()
cm.updateRecharge(now)
cm.curve = curve
if len(curve) > 0 {
cm.totalRecharge = curve[len(curve)-1].Y
@ -165,13 +162,10 @@ func (cm *ClientManager) SetCapacityLimits(min, max, raiseThreshold uint64) {
if min < 1 {
min = 1
}
cm.minLogTotalCap = math.Log(float64(min))
if max < 1 {
max = 1
}
cm.maxLogTotalCap = math.Log(float64(max))
cm.logTotalCap = cm.maxLogTotalCap
cm.capacityRaiseThreshold = raiseThreshold
@ -186,11 +180,9 @@ func (cm *ClientManager) connect(node *ClientNode) {
now := cm.clock.Now()
cm.updateRecharge(now)
node.corrBufValue = int64(node.params.BufLimit)
node.rcLastIntValue = cm.rcLastIntValue
node.queueIndex = -1
cm.updateTotalCapacity(now, true)
cm.totalConnected += node.params.MinRecharge
cm.updateRaiseLimit()
@ -218,7 +210,6 @@ func (cm *ClientManager) accepted(node *ClientNode, maxCost uint64, now mclock.A
cm.updateNodeRc(node, -int64(maxCost), &node.params, now)
rcTime := (node.params.BufLimit - uint64(node.corrBufValue)) * FixedPointMultiplier / node.params.MinRecharge
return -int64(now) - int64(rcTime)
}
@ -230,7 +221,6 @@ func (cm *ClientManager) processed(node *ClientNode, maxCost, realCost uint64, n
if realCost > maxCost {
realCost = maxCost
}
cm.updateBuffer(node, int64(maxCost-realCost), now)
}
@ -241,12 +231,10 @@ func (cm *ClientManager) updateBuffer(node *ClientNode, add int64, now mclock.Ab
defer cm.lock.Unlock()
cm.updateNodeRc(node, add, &node.params, now)
if node.corrBufValue > node.bufValue {
if node.log != nil {
node.log.add(now, fmt.Sprintf("corrected bv=%d oldBv=%d", node.corrBufValue, node.bufValue))
}
node.bufValue = node.corrBufValue
}
}
@ -270,18 +258,14 @@ func (cm *ClientManager) updateRaiseLimit() {
cm.logTotalCapRaiseLimit = 0
return
}
limit := float64(cm.totalConnected + cm.capacityRaiseThreshold)
limit2 := float64(cm.totalConnected) * capacityRaiseThresholdRatio
if limit2 > limit {
limit = limit2
}
if limit < 1 {
limit = 1
}
cm.logTotalCapRaiseLimit = math.Log(limit)
}
@ -297,15 +281,12 @@ func (cm *ClientManager) updateRecharge(now mclock.AbsTime) {
if sumRecharge > cm.totalRecharge {
sumRecharge = cm.totalRecharge
}
bonusRatio := float64(1)
v := cm.curve.ValueAt(sumRecharge)
s := float64(sumRecharge)
if v > s && s > 0 {
bonusRatio = v / s
}
dt := now - lastUpdate
// fetch the client that finishes first
rcqNode := cm.rcQueue.PopItem() // if sumRecharge > 0 then the queue cannot be empty
@ -316,17 +297,14 @@ func (cm *ClientManager) updateRecharge(now mclock.AbsTime) {
// to current bonusRatio and return
cm.addToQueue(rcqNode)
cm.rcLastIntValue += int64(bonusRatio * float64(dt))
return
}
lastUpdate += dtNext
// finished recharging, update corrBufValue and sumRecharge if necessary and do next step
if rcqNode.corrBufValue < int64(rcqNode.params.BufLimit) {
rcqNode.corrBufValue = int64(rcqNode.params.BufLimit)
cm.sumRecharge -= rcqNode.params.MinRecharge
}
cm.rcLastIntValue = rcqNode.rcFullIntValue
}
}
@ -336,15 +314,12 @@ func (cm *ClientManager) addToQueue(node *ClientNode) {
cm.priorityOffset += 0x4000000000000000
// recreate priority queue with new offset to avoid overflow; should happen very rarely
newRcQueue := prque.New[int64, *ClientNode](func(a *ClientNode, i int) { a.queueIndex = i })
for cm.rcQueue.Size() > 0 {
n := cm.rcQueue.PopItem()
newRcQueue.Push(n, cm.priorityOffset-n.rcFullIntValue)
}
cm.rcQueue = newRcQueue
}
cm.rcQueue.Push(node, cm.priorityOffset-node.rcFullIntValue)
}
@ -352,47 +327,36 @@ func (cm *ClientManager) addToQueue(node *ClientNode) {
// It also adds or removes the rcQueue entry and updates ServerParams and sumRecharge if necessary.
func (cm *ClientManager) updateNodeRc(node *ClientNode, bvc int64, params *ServerParams, now mclock.AbsTime) {
cm.updateRecharge(now)
wasFull := true
if node.corrBufValue != int64(node.params.BufLimit) {
wasFull = false
node.corrBufValue += (cm.rcLastIntValue - node.rcLastIntValue) * int64(node.params.MinRecharge) / FixedPointMultiplier
if node.corrBufValue > int64(node.params.BufLimit) {
node.corrBufValue = int64(node.params.BufLimit)
}
node.rcLastIntValue = cm.rcLastIntValue
}
node.corrBufValue += bvc
diff := int64(params.BufLimit - node.params.BufLimit)
if diff > 0 {
node.corrBufValue += diff
}
isFull := false
if node.corrBufValue >= int64(params.BufLimit) {
node.corrBufValue = int64(params.BufLimit)
isFull = true
}
if !wasFull {
cm.sumRecharge -= node.params.MinRecharge
}
if params != &node.params {
node.params = *params
}
if !isFull {
cm.sumRecharge += node.params.MinRecharge
if node.queueIndex != -1 {
cm.rcQueue.Remove(node.queueIndex)
}
node.rcLastIntValue = cm.rcLastIntValue
node.rcFullIntValue = cm.rcLastIntValue + (int64(node.params.BufLimit)-node.corrBufValue)*FixedPointMultiplier/int64(node.params.MinRecharge)
cm.addToQueue(node)
@ -408,15 +372,12 @@ func (cm *ClientManager) reduceTotalCapacity(frozenCap uint64) {
if frozenCap < cm.totalConnected {
ratio = float64(frozenCap) / float64(cm.totalConnected)
}
now := cm.clock.Now()
cm.updateTotalCapacity(now, false)
cm.logTotalCap -= capacityDropFactor * ratio
if cm.logTotalCap < cm.minLogTotalCap {
cm.logTotalCap = cm.minLogTotalCap
}
cm.updateTotalCapacity(now, true)
}
@ -436,11 +397,9 @@ func (cm *ClientManager) updateTotalCapacity(now mclock.AbsTime, refresh bool) {
cm.logTotalCap = cm.logTotalCapRaiseLimit
}
}
if cm.logTotalCap > cm.maxLogTotalCap {
cm.logTotalCap = cm.maxLogTotalCap
}
if refresh {
cm.refreshCapacity()
}
@ -453,7 +412,6 @@ func (cm *ClientManager) refreshCapacity() {
if totalCapacity >= cm.totalCapacity*0.999 && totalCapacity <= cm.totalCapacity*1.001 {
return
}
cm.totalCapacity = totalCapacity
if cm.totalCapacityCh != nil {
select {
@ -470,7 +428,6 @@ func (cm *ClientManager) SubscribeTotalCapacity(ch chan uint64) uint64 {
defer cm.lock.Unlock()
cm.totalCapacityCh = ch
return uint64(cm.totalCapacity)
}
@ -480,12 +437,10 @@ type PieceWiseLinear []struct{ X, Y uint64 }
// ValueAt returns the curve's value at a given point
func (pwl PieceWiseLinear) ValueAt(x uint64) float64 {
l := 0
h := len(pwl)
if h == 0 {
return 0
}
for h != l {
m := (l + h) / 2
if x > pwl[m].X {
@ -494,21 +449,17 @@ func (pwl PieceWiseLinear) ValueAt(x uint64) float64 {
h = m
}
}
if l == 0 {
return float64(pwl[0].Y)
}
l--
if h == len(pwl) {
return float64(pwl[l].Y)
}
dx := pwl[h].X - pwl[l].X
if dx < 1 {
return float64(pwl[l].Y)
}
return float64(pwl[l].Y) + float64(pwl[h].Y-pwl[l].Y)*float64(x-pwl[l].X)/float64(dx)
}
@ -519,9 +470,7 @@ func (pwl PieceWiseLinear) Valid() bool {
if i.X < lastX {
return false
}
lastX = i.X
}
return true
}

16
les/flowcontrol/manager_test.go
View file

@ -56,29 +56,22 @@ func TestConstantTotalCapacity(t *testing.T) {
}
func testConstantTotalCapacity(t *testing.T, nodeCount, maxCapacityNodes, randomSend int, priorityOverflow bool) {
t.Helper()
clock := &mclock.Simulated{}
nodes := make([]*testNode, nodeCount)
var totalCapacity uint64
for i := range nodes {
nodes[i] = &testNode{capacity: uint64(50000 + rand.Intn(100000))}
totalCapacity += nodes[i].capacity
}
m := NewClientManager(PieceWiseLinear{{0, totalCapacity}}, clock)
if priorityOverflow {
// provoke a situation where rcLastUpdate overflow needs to be handled
m.rcLastIntValue = math.MaxInt64 - 10000000000
}
for _, n := range nodes {
n.bufLimit = n.capacity * 6000
n.node = NewClientNode(m, ServerParams{BufLimit: n.bufLimit, MinRecharge: n.capacity})
}
maxNodes := make([]int, maxCapacityNodes)
for i := range maxNodes {
// we don't care if some indexes are selected multiple times
@ -87,21 +80,18 @@ func testConstantTotalCapacity(t *testing.T, nodeCount, maxCapacityNodes, random
}
var sendCount int
for i := 0; i < testLength; i++ {
now := clock.Now()
for _, idx := range maxNodes {
for nodes[idx].send(t, now) {
}
}
if rand.Intn(testLength) < maxCapacityNodes*3 {
maxNodes[rand.Intn(maxCapacityNodes)] = rand.Intn(nodeCount)
}
sendCount += randomSend
failCount := randomSend * 10
for sendCount > 0 && failCount > 0 {
if nodes[rand.Intn(nodeCount)].send(t, now) {
sendCount--
@ -116,7 +106,6 @@ func testConstantTotalCapacity(t *testing.T, nodeCount, maxCapacityNodes, random
for _, n := range nodes {
totalCost += n.totalCost
}
ratio := float64(totalCost) / float64(totalCapacity) / testLength
if ratio < 0.98 || ratio > 1.02 {
t.Errorf("totalCost/totalCapacity/testLength ratio incorrect (expected: 1, got: %f)", ratio)
@ -127,20 +116,15 @@ func (n *testNode) send(t *testing.T, now mclock.AbsTime) bool {
if now < n.waitUntil {
return false
}
n.index++
if ok, _, _ := n.node.AcceptRequest(0, n.index, testMaxCost); !ok {
t.Fatalf("Rejected request after expected waiting time has passed")
}
rcost := uint64(rand.Int63n(testMaxCost))
bv := n.node.RequestProcessed(0, n.index, testMaxCost, rcost)
if bv < testMaxCost {
n.waitUntil = now + mclock.AbsTime((testMaxCost-bv)*1001000/n.capacity)
}
n.totalCost += rcost
return true
}

57
les/handler_test.go
View file

@ -44,7 +44,6 @@ func expectResponse(r p2p.MsgReader, msgcode, reqID, bv uint64, data interface{}
ReqID, BV uint64
Data interface{}
}
return p2p.ExpectMsg(r, msgcode, resp{reqID, bv, data})
}
@ -59,13 +58,11 @@ func testGetBlockHeaders(t *testing.T, protocol int) {
protocol: protocol,
nopruning: true,
}
server, _, tearDown := newClientServerEnv(t, netconfig)
defer tearDown()
rawPeer, closePeer, _ := server.newRawPeer(t, "peer", protocol)
defer closePeer()
bc := server.handler.blockchain
// Create a "random" unknown hash for testing
@ -171,7 +168,6 @@ func testGetBlockHeaders(t *testing.T, protocol int) {
}
// Run each of the tests and verify the results against the chain
var reqID uint64
for i, tt := range tests {
// Collect the headers to expect in the response
var headers []*types.Header
@ -182,7 +178,6 @@ func testGetBlockHeaders(t *testing.T, protocol int) {
reqID++
sendRequest(rawPeer.app, GetBlockHeadersMsg, reqID, tt.query)
if err := expectResponse(rawPeer.app, BlockHeadersMsg, reqID, testBufLimit, headers); err != nil {
t.Errorf("test %d: headers mismatch: %v", i, err)
}
@ -200,7 +195,6 @@ func testGetBlockBodies(t *testing.T, protocol int) {
protocol: protocol,
nopruning: true,
}
server, _, tearDown := newClientServerEnv(t, netconfig)
defer tearDown()
@ -238,13 +232,10 @@ func testGetBlockBodies(t *testing.T, protocol int) {
}
// Run each of the tests and verify the results against the chain
var reqID uint64
for i, tt := range tests {
// Collect the hashes to request, and the response to expect
var hashes []common.Hash
seen := make(map[int64]bool)
var bodies []*types.Body
for j := 0; j < tt.random; j++ {
@ -255,30 +246,24 @@ func testGetBlockBodies(t *testing.T, protocol int) {
block := bc.GetBlockByNumber(uint64(num))
hashes = append(hashes, block.Hash())
if len(bodies) < tt.expected {
bodies = append(bodies, &types.Body{Transactions: block.Transactions(), Uncles: block.Uncles()})
}
break
}
}
}
for j, hash := range tt.explicit {
hashes = append(hashes, hash)
if tt.available[j] && len(bodies) < tt.expected {
block := bc.GetBlockByHash(hash)
bodies = append(bodies, &types.Body{Transactions: block.Transactions(), Uncles: block.Uncles()})
}
}
reqID++
// Send the hash request and verify the response
sendRequest(rawPeer.app, GetBlockBodiesMsg, reqID, hashes)
if err := expectResponse(rawPeer.app, BlockBodiesMsg, reqID, testBufLimit, bodies); err != nil {
t.Errorf("test %d: bodies mismatch: %v", i, err)
}
@ -297,7 +282,6 @@ func testGetCode(t *testing.T, protocol int) {
protocol: protocol,
nopruning: true,
}
server, _, tearDown := newClientServerEnv(t, netconfig)
defer tearDown()
@ -307,9 +291,7 @@ func testGetCode(t *testing.T, protocol int) {
bc := server.handler.blockchain
var codereqs []*CodeReq
var codes [][]byte
for i := uint64(0); i <= bc.CurrentBlock().Number.Uint64(); i++ {
header := bc.GetHeaderByNumber(i)
req := &CodeReq{
@ -317,14 +299,12 @@ func testGetCode(t *testing.T, protocol int) {
AccountAddress: testContractAddr[:],
}
codereqs = append(codereqs, req)
if i >= testContractDeployed {
codes = append(codes, testContractCodeDeployed)
}
}
sendRequest(rawPeer.app, GetCodeMsg, 42, codereqs)
if err := expectResponse(rawPeer.app, CodeMsg, 42, testBufLimit, codes); err != nil {
t.Errorf("codes mismatch: %v", err)
}
@ -341,7 +321,6 @@ func testGetStaleCode(t *testing.T, protocol int) {
protocol: protocol,
nopruning: true,
}
server, _, tearDown := newClientServerEnv(t, netconfig)
defer tearDown()
@ -356,7 +335,6 @@ func testGetStaleCode(t *testing.T, protocol int) {
AccountAddress: testContractAddr[:],
}
sendRequest(rawPeer.app, GetCodeMsg, 42, []*CodeReq{req})
if err := expectResponse(rawPeer.app, CodeMsg, 42, testBufLimit, expected); err != nil {
t.Errorf("codes mismatch: %v", err)
}
@ -378,7 +356,6 @@ func testGetReceipt(t *testing.T, protocol int) {
protocol: protocol,
nopruning: true,
}
server, _, tearDown := newClientServerEnv(t, netconfig)
defer tearDown()
@ -389,9 +366,7 @@ func testGetReceipt(t *testing.T, protocol int) {
// Collect the hashes to request, and the response to expect
var receipts []types.Receipts
var hashes []common.Hash
for i := uint64(0); i <= bc.CurrentBlock().Number.Uint64(); i++ {
block := bc.GetBlockByNumber(i)
@ -400,7 +375,6 @@ func testGetReceipt(t *testing.T, protocol int) {
}
// Send the hash request and verify the response
sendRequest(rawPeer.app, GetReceiptsMsg, 42, hashes)
if err := expectResponse(rawPeer.app, ReceiptsMsg, 42, testBufLimit, receipts); err != nil {
t.Errorf("receipts mismatch: %v", err)
}
@ -418,7 +392,6 @@ func testGetProofs(t *testing.T, protocol int) {
protocol: protocol,
nopruning: true,
}
server, _, tearDown := newClientServerEnv(t, netconfig)
defer tearDown()
@ -428,11 +401,9 @@ func testGetProofs(t *testing.T, protocol int) {
bc := server.handler.blockchain
var proofreqs []ProofReq
proofsV2 := light.NewNodeSet()
accounts := []common.Address{bankAddr, userAddr1, userAddr2, signerAddr, {}}
for i := uint64(0); i <= bc.CurrentBlock().Number.Uint64(); i++ {
header := bc.GetHeaderByNumber(i)
trie, _ := trie.New(trie.StateTrieID(header.Root), trie.NewDatabase(server.db))
@ -443,13 +414,11 @@ func testGetProofs(t *testing.T, protocol int) {
Key: crypto.Keccak256(acc[:]),
}
proofreqs = append(proofreqs, req)
trie.Prove(crypto.Keccak256(acc[:]), 0, proofsV2)
trie.Prove(crypto.Keccak256(acc[:]), proofsV2)
}
}
// Send the proof request and verify the response
sendRequest(rawPeer.app, GetProofsV2Msg, 42, proofreqs)
if err := expectResponse(rawPeer.app, ProofsV2Msg, 42, testBufLimit, proofsV2.NodeList()); err != nil {
t.Errorf("proofs mismatch: %v", err)
}
@ -466,7 +435,6 @@ func testGetStaleProof(t *testing.T, protocol int) {
protocol: protocol,
nopruning: true,
}
server, _, tearDown := newClientServerEnv(t, netconfig)
defer tearDown()
@ -480,7 +448,6 @@ func testGetStaleProof(t *testing.T, protocol int) {
header = bc.GetHeaderByNumber(number)
account = crypto.Keccak256(userAddr1.Bytes())
)
req := &ProofReq{
BHash: header.Hash(),
Key: account,
@ -488,14 +455,12 @@ func testGetStaleProof(t *testing.T, protocol int) {
sendRequest(rawPeer.app, GetProofsV2Msg, 42, []*ProofReq{req})
var expected []rlp.RawValue
if wantOK {
proofsV2 := light.NewNodeSet()
t, _ := trie.New(trie.StateTrieID(header.Root), trie.NewDatabase(server.db))
t.Prove(account, proofsV2)
expected = proofsV2.NodeList()
}
if err := expectResponse(rawPeer.app, ProofsV2Msg, 42, testBufLimit, expected); err != nil {
t.Errorf("codes mismatch: %v", err)
}
@ -529,7 +494,6 @@ func testGetCHTProofs(t *testing.T, protocol int) {
nopruning: true,
}
)
server, _, tearDown := newClientServerEnv(t, netconfig)
defer tearDown()
@ -560,7 +524,6 @@ func testGetCHTProofs(t *testing.T, protocol int) {
}}
// Send the proof request and verify the response
sendRequest(rawPeer.app, GetHelperTrieProofsMsg, 42, requestsV2)
if err := expectResponse(rawPeer.app, HelperTrieProofsMsg, 42, testBufLimit, proofsV2); err != nil {
t.Errorf("proofs mismatch: %v", err)
}
@ -590,7 +553,6 @@ func testGetBloombitsProofs(t *testing.T, protocol int) {
nopruning: true,
}
)
server, _, tearDown := newClientServerEnv(t, netconfig)
defer tearDown()
@ -613,7 +575,6 @@ func testGetBloombitsProofs(t *testing.T, protocol int) {
TrieIdx: 0,
Key: key,
}}
var proofs HelperTrieResps
root := light.GetBloomTrieRoot(server.db, 0, bc.GetHeaderByNumber(config.BloomTrieSize-1).Hash())
@ -622,7 +583,6 @@ func testGetBloombitsProofs(t *testing.T, protocol int) {
// Send the proof request and verify the response
sendRequest(rawPeer.app, GetHelperTrieProofsMsg, 42, requests)
if err := expectResponse(rawPeer.app, HelperTrieProofsMsg, 42, testBufLimit, proofs); err != nil {
t.Errorf("bit %d: proofs mismatch: %v", bit, err)
}
@ -638,7 +598,6 @@ func testTransactionStatus(t *testing.T, protocol int) {
protocol: protocol,
nopruning: true,
}
server, _, tearDown := newClientServerEnv(t, netconfig)
defer tearDown()
@ -660,9 +619,8 @@ func testTransactionStatus(t *testing.T, protocol int) {
} else {
sendRequest(rawPeer.app, GetTxStatusMsg, reqID, []common.Hash{tx.Hash()})
}
if err := expectResponse(rawPeer.app, TxStatusMsg, reqID, testBufLimit, []light.TxStatus{expStatus}); err != nil {
t.Error("transaction status mismatch", err)
t.Errorf("transaction status mismatch: %v", err)
}
}
signer := types.HomesteadSigner{}
@ -697,10 +655,8 @@ func testTransactionStatus(t *testing.T, protocol int) {
if pending, _ := server.handler.txpool.Stats(); pending == 1 {
break
}
time.Sleep(100 * time.Millisecond)
}
if pending, _ := server.handler.txpool.Stats(); pending != 1 {
t.Fatalf("pending count mismatch: have %d, want 1", pending)
}
@ -710,7 +666,6 @@ func testTransactionStatus(t *testing.T, protocol int) {
// check if their status is included now
block1hash := rawdb.ReadCanonicalHash(server.db, 1)
test(tx1, false, light.TxStatus{Status: txpool.TxStatusIncluded, Lookup: &rawdb.LegacyTxLookupEntry{BlockHash: block1hash, BlockIndex: 1, Index: 0}})
test(tx2, false, light.TxStatus{Status: txpool.TxStatusIncluded, Lookup: &rawdb.LegacyTxLookupEntry{BlockHash: block1hash, BlockIndex: 1, Index: 1}})
@ -725,10 +680,8 @@ func testTransactionStatus(t *testing.T, protocol int) {
if pending, _ := server.handler.txpool.Stats(); pending == 3 {
break
}
time.Sleep(100 * time.Millisecond)
}
if pending, _ := server.handler.txpool.Stats(); pending != 3 {
t.Fatalf("pending count mismatch: have %d, want 3", pending)
}
@ -750,7 +703,6 @@ func testStopResume(t *testing.T, protocol int) {
simClock: true,
nopruning: true,
}
server, _, tearDown := newClientServerEnv(t, netconfig)
defer tearDown()
@ -765,18 +717,15 @@ func testStopResume(t *testing.T, protocol int) {
expBuf = testBufLimit
testCost = testBufLimit / 10
)
header := server.handler.blockchain.CurrentHeader()
req := func() {
reqID++
sendRequest(rawPeer.app, GetBlockHeadersMsg, reqID, &GetBlockHeadersData{Origin: hashOrNumber{Hash: header.Hash()}, Amount: 1})
}
for i := 1; i <= 5; i++ {
// send requests while we still have enough buffer and expect a response
for expBuf >= testCost {
req()
expBuf -= testCost
if err := expectResponse(rawPeer.app, BlockHeadersMsg, reqID, expBuf, []*types.Header{header}); err != nil {
t.Errorf("expected response and failed: %v", err)
@ -786,10 +735,8 @@ func testStopResume(t *testing.T, protocol int) {
c := i
for c > 0 {
req()
c--
}
if err := p2p.ExpectMsg(rawPeer.app, StopMsg, nil); err != nil {
t.Errorf("expected StopMsg and failed: %v", err)
}

1
les/metrics.go
View file

@ -123,7 +123,6 @@ func newMeteredMsgWriter(rw p2p.MsgReadWriter, version int) p2p.MsgReadWriter {
if !metrics.Enabled {
return rw
}
return &meteredMsgReadWriter{MsgReadWriter: rw, version: version}
}

16
les/odr.go
View file

@ -112,11 +112,9 @@ func (h peerByTxHistory) Less(i, j int) bool {
if h[i].txHistory == txIndexUnlimited {
return false
}
if h[j].txHistory == txIndexUnlimited {
return true
}
return h[i].txHistory < h[j].txHistory
}
func (h peerByTxHistory) Swap(i, j int) { h[i], h[j] = h[j], h[i] }
@ -142,17 +140,13 @@ func (odr *LesOdr) RetrieveTxStatus(ctx context.Context, req *light.TxStatusRequ
result = make([]light.TxStatus, len(req.Hashes))
canSend = make(map[string]bool)
)
for _, peer := range odr.peers.allPeers() {
if peer.txHistory == txIndexDisabled {
continue
}
peers = append(peers, peer)
}
sort.Sort(sort.Reverse(peerByTxHistory(peers)))
for i := 0; i < maxTxStatusCandidates && i < len(peers); i++ {
canSend[peers[i].id] = true
}
@ -161,7 +155,6 @@ func (odr *LesOdr) RetrieveTxStatus(ctx context.Context, req *light.TxStatusRequ
if retries >= maxTxStatusRetry || len(canSend) == 0 {
break
}
var (
// Deep copy the request, so that the partial result won't be mixed.
req = &TxStatusRequest{Hashes: req.Hashes}
@ -177,7 +170,6 @@ func (odr *LesOdr) RetrieveTxStatus(ctx context.Context, req *light.TxStatusRequ
},
}
)
if err := odr.retriever.retrieve(ctx, id, distreq, func(p distPeer, msg *Msg) error { return req.Validate(odr.db, msg) }, odr.stop); err != nil {
return err
}
@ -188,23 +180,18 @@ func (odr *LesOdr) RetrieveTxStatus(ctx context.Context, req *light.TxStatusRequ
if result[index].Status != txpool.TxStatusUnknown {
continue
}
if status.Status == txpool.TxStatusUnknown {
continue
}
result[index], missing = status, missing-1
}
// Abort the procedure if all the status are retrieved
if missing == 0 {
break
}
retries += 1
}
req.Status = result
return nil
}
@ -239,15 +226,12 @@ func (odr *LesOdr) Retrieve(ctx context.Context, req light.OdrRequest) (err erro
if err != nil {
return
}
requestRTT.Update(time.Duration(mclock.Now() - sent))
}(mclock.Now())
if err := odr.retriever.retrieve(ctx, reqID, rq, func(p distPeer, msg *Msg) error { return lreq.Validate(odr.db, msg) }, odr.stop); err != nil {
return err
}
req.StoreResult(odr.db)
return nil
}

50
les/odr_requests.go
View file

@ -103,27 +103,22 @@ func (r *BlockRequest) Validate(db ethdb.Database, msg *Msg) error {
if msg.MsgType != MsgBlockBodies {
return errInvalidMessageType
}
bodies := msg.Obj.([]*types.Body)
if len(bodies) != 1 {
return errInvalidEntryCount
}
body := bodies[0]
// Retrieve our stored header and validate block content against it
if r.Header == nil {
r.Header = rawdb.ReadHeader(db, r.Hash, r.Number)
}
if r.Header == nil {
return errHeaderUnavailable
}
if r.Header.TxHash != types.DeriveSha(types.Transactions(body.Transactions), trie.NewStackTrie(nil)) {
return errTxHashMismatch
}
if r.Header.UncleHash != types.CalcUncleHash(body.Uncles) {
return errUncleHashMismatch
}
@ -132,9 +127,7 @@ func (r *BlockRequest) Validate(db ethdb.Database, msg *Msg) error {
if err != nil {
return err
}
r.Rlp = data
return nil
}
@ -168,29 +161,24 @@ func (r *ReceiptsRequest) Validate(db ethdb.Database, msg *Msg) error {
if msg.MsgType != MsgReceipts {
return errInvalidMessageType
}
receipts := msg.Obj.([]types.Receipts)
if len(receipts) != 1 {
return errInvalidEntryCount
}
receipt := receipts[0]
// Retrieve our stored header and validate receipt content against it
if r.Header == nil {
r.Header = rawdb.ReadHeader(db, r.Hash, r.Number)
}
if r.Header == nil {
return errHeaderUnavailable
}
if r.Header.ReceiptHash != types.DeriveSha(receipt, trie.NewStackTrie(nil)) {
return errReceiptHashMismatch
}
// Validations passed, store and return
r.Receipts = receipt
return nil
}
@ -222,7 +210,6 @@ func (r *TrieRequest) Request(reqID uint64, peer *serverPeer) error {
AccountAddress: r.Id.AccountAddress,
Key: r.Key,
}
return peer.requestProofs(reqID, []ProofReq{req})
}
@ -235,11 +222,9 @@ func (r *TrieRequest) Validate(db ethdb.Database, msg *Msg) error {
if msg.MsgType != MsgProofsV2 {
return errInvalidMessageType
}
proofs := msg.Obj.(light.NodeList)
// Verify the proof and store if checks out
nodeSet := proofs.NodeSet()
reads := &readTraceDB{db: nodeSet}
if _, err := trie.VerifyProof(r.Id.Root, r.Key, reads); err != nil {
return fmt.Errorf("merkle proof verification failed: %v", err)
@ -248,9 +233,7 @@ func (r *TrieRequest) Validate(db ethdb.Database, msg *Msg) error {
if len(reads.reads) != nodeSet.KeyCount() {
return errUselessNodes
}
r.Proof = nodeSet
return nil
}
@ -280,7 +263,6 @@ func (r *CodeRequest) Request(reqID uint64, peer *serverPeer) error {
BHash: r.Id.BlockHash,
AccountAddress: r.Id.AccountAddress,
}
return peer.requestCode(reqID, []CodeReq{req})
}
@ -294,21 +276,17 @@ func (r *CodeRequest) Validate(db ethdb.Database, msg *Msg) error {
if msg.MsgType != MsgCode {
return errInvalidMessageType
}
reply := msg.Obj.([][]byte)
if len(reply) != 1 {
return errInvalidEntryCount
}
data := reply[0]
// Verify the data and store if checks out
if hash := crypto.Keccak256Hash(data); r.Hash != hash {
return errDataHashMismatch
}
r.Data = data
return nil
}
@ -354,9 +332,7 @@ func (r *ChtRequest) CanSend(peer *serverPeer) bool {
// Request sends an ODR request to the LES network (implementation of LesOdrRequest)
func (r *ChtRequest) Request(reqID uint64, peer *serverPeer) error {
peer.Log().Debug("Requesting CHT", "cht", r.ChtNum, "block", r.BlockNum)
var encNum [8]byte
binary.BigEndian.PutUint64(encNum[:], r.BlockNum)
req := HelperTrieReq{
Type: htCanonical,
@ -364,7 +340,6 @@ func (r *ChtRequest) Request(reqID uint64, peer *serverPeer) error {
Key: encNum[:],
AuxReq: htAuxHeader,
}
return peer.requestHelperTrieProofs(reqID, []HelperTrieReq{req})
}
@ -377,19 +352,15 @@ func (r *ChtRequest) Validate(db ethdb.Database, msg *Msg) error {
if msg.MsgType != MsgHelperTrieProofs {
return errInvalidMessageType
}
resp := msg.Obj.(HelperTrieResps)
if len(resp.AuxData) != 1 {
return errInvalidEntryCount
}
nodeSet := resp.Proofs.NodeSet()
headerEnc := resp.AuxData[0]
if len(headerEnc) == 0 {
return errHeaderUnavailable
}
header := new(types.Header)
if err := rlp.DecodeBytes(headerEnc, header); err != nil {
return errHeaderUnavailable
@ -399,28 +370,22 @@ func (r *ChtRequest) Validate(db ethdb.Database, msg *Msg) error {
node light.ChtNode
encNumber [8]byte
)
binary.BigEndian.PutUint64(encNumber[:], r.BlockNum)
reads := &readTraceDB{db: nodeSet}
value, err := trie.VerifyProof(r.ChtRoot, encNumber[:], reads)
if err != nil {
return fmt.Errorf("merkle proof verification failed: %v", err)
}
if len(reads.reads) != nodeSet.KeyCount() {
return errUselessNodes
}
if err := rlp.DecodeBytes(value, &node); err != nil {
return err
}
if node.Hash != header.Hash() {
return errCHTHashMismatch
}
if r.BlockNum != header.Number.Uint64() {
return errCHTNumberMismatch
}
@ -428,7 +393,6 @@ func (r *ChtRequest) Validate(db ethdb.Database, msg *Msg) error {
r.Header = header
r.Proof = nodeSet
r.Td = node.Td
return nil
}
@ -453,7 +417,6 @@ func (r *BloomRequest) CanSend(peer *serverPeer) bool {
if peer.version < lpv2 {
return false
}
return peer.headInfo.Number >= r.Config.BloomTrieConfirms && r.BloomTrieNum <= (peer.headInfo.Number-r.Config.BloomTrieConfirms)/r.Config.BloomTrieSize
}
@ -463,7 +426,6 @@ func (r *BloomRequest) Request(reqID uint64, peer *serverPeer) error {
reqs := make([]HelperTrieReq, len(r.SectionIndexList))
var encNumber [10]byte
binary.BigEndian.PutUint16(encNumber[:2], uint16(r.BitIdx))
for i, sectionIdx := range r.SectionIndexList {
@ -474,7 +436,6 @@ func (r *BloomRequest) Request(reqID uint64, peer *serverPeer) error {
Key: common.CopyBytes(encNumber[:]),
}
}
return peer.requestHelperTrieProofs(reqID, reqs)
}
@ -488,7 +449,6 @@ func (r *BloomRequest) Validate(db ethdb.Database, msg *Msg) error {
if msg.MsgType != MsgHelperTrieProofs {
return errInvalidMessageType
}
resps := msg.Obj.(HelperTrieResps)
proofs := resps.Proofs
nodeSet := proofs.NodeSet()
@ -498,26 +458,21 @@ func (r *BloomRequest) Validate(db ethdb.Database, msg *Msg) error {
// Verify the proofs
var encNumber [10]byte
binary.BigEndian.PutUint16(encNumber[:2], uint16(r.BitIdx))
for i, idx := range r.SectionIndexList {
binary.BigEndian.PutUint64(encNumber[2:], idx)
value, err := trie.VerifyProof(r.BloomTrieRoot, encNumber[:], reads)
if err != nil {
return err
}
r.BloomBits[i] = value
}
if len(reads.reads) != nodeSet.KeyCount() {
return errUselessNodes
}
r.Proofs = nodeSet
return nil
}
@ -550,14 +505,11 @@ func (r *TxStatusRequest) Validate(db ethdb.Database, msg *Msg) error {
if msg.MsgType != MsgTxStatus {
return errInvalidMessageType
}
status := msg.Obj.([]light.TxStatus)
if len(status) != len(r.Hashes) {
return errInvalidEntryCount
}
r.Status = status
return nil
}
@ -573,9 +525,7 @@ func (db *readTraceDB) Get(k []byte) ([]byte, error) {
if db.reads == nil {
db.reads = make(map[string]struct{})
}
db.reads[string(k)] = struct{}{}
return db.db.Get(k)
}

51
les/odr_test.go
View file

@ -57,13 +57,10 @@ func odrGetBlock(ctx context.Context, db ethdb.Database, config *params.ChainCon
} else {
block, _ = lc.GetBlockByHash(ctx, bhash)
}
if block == nil {
return nil
}
rlp, _ := rlp.EncodeToBytes(block)
return rlp
}
@ -73,7 +70,6 @@ func TestOdrGetReceiptsLes4(t *testing.T) { testOdr(t, 4, 1, true, odrGetReceipt
func odrGetReceipts(ctx context.Context, db ethdb.Database, config *params.ChainConfig, bc *core.BlockChain, lc *light.LightChain, bhash common.Hash) []byte {
var receipts types.Receipts
if bc != nil {
if number := rawdb.ReadHeaderNumber(db, bhash); number != nil {
if header := rawdb.ReadHeader(db, bhash, *number); header != nil {
@ -85,13 +81,10 @@ func odrGetReceipts(ctx context.Context, db ethdb.Database, config *params.Chain
receipts, _ = light.GetBlockReceipts(ctx, lc.Odr(), bhash, *number)
}
}
if receipts == nil {
return nil
}
rlp, _ := rlp.EncodeToBytes(receipts)
return rlp
}
@ -108,7 +101,6 @@ func odrAccounts(ctx context.Context, db ethdb.Database, config *params.ChainCon
st *state.StateDB
err error
)
for _, addr := range acc {
if bc != nil {
header := bc.GetHeaderByHash(bhash)
@ -117,14 +109,12 @@ func odrAccounts(ctx context.Context, db ethdb.Database, config *params.ChainCon
header := lc.GetHeaderByHash(bhash)
st = light.NewState(ctx, header, lc.Odr())
}
if err == nil {
bal := st.GetBalance(addr)
rlp, _ := rlp.EncodeToBytes(bal)
res = append(res, rlp...)
}
}
return res
}
@ -136,10 +126,8 @@ func odrContractCall(ctx context.Context, db ethdb.Database, config *params.Chai
data := common.Hex2Bytes("60CD26850000000000000000000000000000000000000000000000000000000000000000")
var res []byte
for i := 0; i < 3; i++ {
data[35] = byte(i)
if bc != nil {
header := bc.GetHeaderByHash(bhash)
statedb, err := state.New(header.Root, bc.StateCache(), nil)
@ -160,14 +148,13 @@ func odrContractCall(ctx context.Context, db ethdb.Database, config *params.Chai
SkipAccountChecks: true,
}
blockContext := core.NewEVMBlockContext(header, bc, nil)
context := core.NewEVMBlockContext(header, bc, nil)
txContext := core.NewEVMTxContext(msg)
vmenv := vm.NewEVM(blockContext, txContext, statedb, config, vm.Config{NoBaseFee: true})
vmenv := vm.NewEVM(context, txContext, statedb, config, vm.Config{NoBaseFee: true})
//vmenv := core.NewEnv(statedb, config, bc, msg, header, vm.Config{})
gp := new(core.GasPool).AddGas(math.MaxUint64)
// nolint : contextcheck
result, _ := core.ApplyMessage(vmenv, msg, gp, context.Background())
result, _ := core.ApplyMessage(vmenv, msg, gp)
res = append(res, result.Return()...)
}
} else {
@ -185,18 +172,16 @@ func odrContractCall(ctx context.Context, db ethdb.Database, config *params.Chai
Data: data,
SkipAccountChecks: true,
}
blockContext := core.NewEVMBlockContext(header, lc, nil)
context := core.NewEVMBlockContext(header, lc, nil)
txContext := core.NewEVMTxContext(msg)
vmenv := vm.NewEVM(blockContext, txContext, state, config, vm.Config{NoBaseFee: true})
vmenv := vm.NewEVM(context, txContext, state, config, vm.Config{NoBaseFee: true})
gp := new(core.GasPool).AddGas(math.MaxUint64)
// nolint : contextcheck
result, _ := core.ApplyMessage(vmenv, msg, gp, context.Background())
result, _ := core.ApplyMessage(vmenv, msg, gp)
if state.Error() == nil {
res = append(res, result.Return()...)
}
}
}
return res
}
@ -206,7 +191,6 @@ func TestOdrTxStatusLes4(t *testing.T) { testOdr(t, 4, 1, false, odrTxStatus) }
func odrTxStatus(ctx context.Context, db ethdb.Database, config *params.ChainConfig, bc *core.BlockChain, lc *light.LightChain, bhash common.Hash) []byte {
var txs types.Transactions
if bc != nil {
block := bc.GetBlockByHash(bhash)
txs = block.Transactions()
@ -214,10 +198,8 @@ func odrTxStatus(ctx context.Context, db ethdb.Database, config *params.ChainCon
if block, _ := lc.GetBlockByHash(ctx, bhash); block != nil {
btxs := block.Transactions()
txs = make(types.Transactions, len(btxs))
for i, tx := range btxs {
var err error
txs[i], _, _, _, err = light.GetTransaction(ctx, lc.Odr(), tx.Hash())
if err != nil {
return nil
@ -225,9 +207,7 @@ func odrTxStatus(ctx context.Context, db ethdb.Database, config *params.ChainCon
}
}
}
rlp, _ := rlp.EncodeToBytes(txs)
return rlp
}
@ -240,7 +220,6 @@ func testOdr(t *testing.T, protocol int, expFail uint64, checkCached bool, fn od
connect: true,
nopruning: true,
}
server, client, tearDown := newClientServerEnv(t, netconfig)
defer tearDown()
@ -265,16 +244,13 @@ func testOdr(t *testing.T, protocol int, expFail uint64, checkCached bool, fn od
// for travis to make the action.
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
b2 := fn(ctx, client.db, client.handler.backend.chainConfig, nil, client.handler.backend.blockchain, bhash)
cancel()
eq := bytes.Equal(b1, b2)
exp := i < expFail
if exp && !eq {
t.Fatalf("odr mismatch: have %x, want %x", b2, b1)
}
if !exp && eq {
t.Fatalf("unexpected odr match")
}
@ -312,7 +288,6 @@ func testGetTxStatusFromUnindexedPeers(t *testing.T, protocol int) {
nopruning: true,
}
)
server, client, tearDown := newClientServerEnv(t, netconfig)
defer tearDown()
@ -326,13 +301,11 @@ func testGetTxStatusFromUnindexedPeers(t *testing.T, protocol int) {
blockHashes = make(map[common.Hash]common.Hash) // Transaction hash to block hash mappings
intraIndex = make(map[common.Hash]uint64) // Transaction intra-index in block
)
for number := uint64(1); number < server.backend.Blockchain().CurrentBlock().Number.Uint64(); number++ {
block := server.backend.Blockchain().GetBlockByNumber(number)
if block == nil {
t.Fatalf("Failed to retrieve block %d", number)
}
for index, tx := range block.Transactions() {
txs[tx.Hash()] = tx
blockNumbers[tx.Hash()] = number
@ -358,29 +331,23 @@ func testGetTxStatusFromUnindexedPeers(t *testing.T, protocol int) {
if err != nil {
return err
}
if msg.Code != GetTxStatusMsg {
return fmt.Errorf("message code mismatch: got %d, expected %d", msg.Code, GetTxStatusMsg)
}
var r GetTxStatusPacket
if err := msg.Decode(&r); err != nil {
return err
}
stats := make([]light.TxStatus, len(r.Hashes))
for i, hash := range r.Hashes {
number, exist := blockNumbers[hash]
if !exist {
continue // Filter out unknown transactions
}
min := uint64(blocks) - txLookup
if txLookup != txIndexUnlimited && (txLookup == txIndexDisabled || number < min) {
continue // Filter out unindexed transactions
}
stats[i].Status = txpool.TxStatusIncluded
stats[i].Lookup = &rawdb.LegacyTxLookupEntry{
BlockHash: blockHashes[hash],
@ -388,11 +355,9 @@ func testGetTxStatusFromUnindexedPeers(t *testing.T, protocol int) {
Index: intraIndex[hash],
}
}
data, _ := rlp.EncodeToBytes(stats)
reply := &reply{peer.app, TxStatusMsg, r.ReqID, data}
reply.send(testBufLimit)
return nil
}
@ -445,13 +410,11 @@ func testGetTxStatusFromUnindexedPeers(t *testing.T, protocol int) {
results: []light.TxStatus{{}, {}},
},
}
for _, testspec := range testspecs {
// Create a bunch of server peers with different tx history
var (
closeFns []func()
)
for i := 0; i < testspec.peers; i++ {
peer, closePeer, _ := client.newRawPeer(t, fmt.Sprintf("server-%d", i), protocol, testspec.txLookups[i])
closeFns = append(closeFns, closePeer)
@ -465,7 +428,6 @@ func testGetTxStatusFromUnindexedPeers(t *testing.T, protocol int) {
// Send out the GetTxStatus requests, compare the result with
// expected value.
r := &light.TxStatusRequest{Hashes: testspec.txs}
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
@ -491,7 +453,6 @@ func randomHash() common.Hash {
if n, err := rand.Read(hash[:]); n != common.HashLength || err != nil {
panic(err)
}
return hash
}
*/

134
les/peer.go
View file

@ -85,29 +85,23 @@ type keyValueMap map[string]rlp.RawValue
func (l keyValueList) add(key string, val interface{}) keyValueList {
var entry keyValueEntry
entry.Key = key
if val == nil {
val = uint64(0)
}
enc, err := rlp.EncodeToBytes(val)
if err == nil {
entry.Value = enc
}
return append(l, entry)
}
func (l keyValueList) decode() (keyValueMap, uint64) {
m := make(keyValueMap)
var size uint64
for _, entry := range l {
m[entry.Key] = entry.Value
size += uint64(len(entry.Key)) + uint64(len(entry.Value)) + 8
}
return m, size
}
@ -116,11 +110,9 @@ func (m keyValueMap) get(key string, val interface{}) error {
if !ok {
return errResp(ErrMissingKey, "%s", key)
}
if val == nil {
return nil
}
return rlp.DecodeBytes(enc, val)
}
@ -229,12 +221,10 @@ func (p *peerCommons) sendReceiveHandshake(sendList keyValueList) (keyValueList,
errc <- err
return
}
if msg.Code != StatusMsg {
errc <- errResp(ErrNoStatusMsg, "first msg has code %x (!= %x)", msg.Code, StatusMsg)
return
}
if msg.Size > ProtocolMaxMsgSize {
errc <- errResp(ErrMsgTooLarge, "%v > %v", msg.Size, ProtocolMaxMsgSize)
return
@ -246,10 +236,8 @@ func (p *peerCommons) sendReceiveHandshake(sendList keyValueList) (keyValueList,
}
errc <- nil
}()
timeout := time.NewTimer(handshakeTimeout)
defer timeout.Stop()
for i := 0; i < 2; i++ {
select {
case err := <-errc:
@ -260,7 +248,6 @@ func (p *peerCommons) sendReceiveHandshake(sendList keyValueList) (keyValueList,
return nil, p2p.DiscReadTimeout
}
}
return recvList, nil
}
@ -299,35 +286,27 @@ func (p *peerCommons) handshake(td *big.Int, head common.Hash, headNum uint64, g
if err != nil {
return err
}
recv, size := recvList.decode()
if size > allowedUpdateBytes {
return errResp(ErrRequestRejected, "")
}
var rGenesis common.Hash
var rVersion, rNetwork uint64
if err := recv.get("protocolVersion", &rVersion); err != nil {
return err
}
if err := recv.get("networkId", &rNetwork); err != nil {
return err
}
if err := recv.get("genesisHash", &rGenesis); err != nil {
return err
}
if rGenesis != genesis {
return errResp(ErrGenesisBlockMismatch, "%x (!= %x)", rGenesis[:8], genesis[:8])
}
if rNetwork != p.network {
return errResp(ErrNetworkIdMismatch, "%d (!= %d)", rNetwork, p.network)
}
if int(rVersion) != p.version {
return errResp(ErrProtocolVersionMismatch, "%d (!= %d)", rVersion, p.version)
}
@ -337,16 +316,13 @@ func (p *peerCommons) handshake(td *big.Int, head common.Hash, headNum uint64, g
if err := recv.get("forkID", &forkID); err != nil {
return err
}
if err := forkFilter(forkID); err != nil {
return errResp(ErrForkIDRejected, "%v", err)
}
}
if recvCallback != nil {
return recvCallback(recv)
}
return nil
}
@ -415,9 +391,7 @@ func (p *serverPeer) rejectUpdate(size uint64) bool {
p.updateCount = 0
}
}
p.updateCount += size
return p.updateCount > allowedUpdateBytes
}
@ -442,7 +416,6 @@ func sendRequest(w p2p.MsgWriter, msgcode, reqID uint64, data interface{}) error
ReqID uint64
Data interface{}
}
return p2p.Send(w, msgcode, &req{reqID, data})
}
@ -506,12 +479,10 @@ func (p *serverPeer) requestTxStatus(reqID uint64, txHashes []common.Hash) error
// sendTxs creates a reply with a batch of transactions to be added to the remote transaction pool.
func (p *serverPeer) sendTxs(reqID uint64, amount int, txs rlp.RawValue) error {
p.Log().Debug("Sending batch of transactions", "amount", amount, "size", len(txs))
sizeFactor := (len(txs) + txSizeCostLimit/2) / txSizeCostLimit
if sizeFactor > amount {
amount = sizeFactor
}
return p.sendRequest(SendTxV2Msg, reqID, txs, amount)
}
@ -530,12 +501,10 @@ func (p *serverPeer) getRequestCost(msgcode uint64, amount int) uint64 {
if costs == nil {
return 0
}
cost := costs.baseCost + costs.reqCost*uint64(amount)
if cost > p.fcParams.BufLimit {
cost = p.fcParams.BufLimit
}
return cost
}
@ -549,18 +518,14 @@ func (p *serverPeer) getTxRelayCost(amount, size int) uint64 {
if costs == nil {
return 0
}
cost := costs.baseCost + costs.reqCost*uint64(amount)
sizeCost := costs.baseCost + costs.reqCost*uint64(size)/txSizeCostLimit
if sizeCost > cost {
cost = sizeCost
}
if cost > p.fcParams.BufLimit {
cost = p.fcParams.BufLimit
}
return cost
}
@ -572,9 +537,7 @@ func (p *serverPeer) HasBlock(hash common.Hash, number uint64, hasState bool) bo
if p.hasBlockHook != nil {
return p.hasBlockHook(hash, number, hasState)
}
head := p.headInfo.Number
var since, recent uint64
if hasState {
since = p.stateSince
@ -583,7 +546,6 @@ func (p *serverPeer) HasBlock(hash common.Hash, number uint64, hasState bool) bo
since = p.chainSince
recent = p.chainRecent
}
return head >= number && number >= since && (recent == 0 || number+recent+4 > head)
}
@ -600,7 +562,6 @@ func (p *serverPeer) updateFlowControl(update keyValueMap) {
p.fcParams = params
p.fcServer.UpdateParams(params)
}
var MRC RequestCostList
if update.get("flowControl/MRC", &MRC) == nil {
costUpdate := MRC.decode(ProtocolLengths[uint(p.version)])
@ -632,7 +593,6 @@ func (p *serverPeer) Handshake(genesis common.Hash, forkid forkid.ID, forkFilter
if p.trusted {
p.announceType = announceTypeSigned
}
*lists = (*lists).add("announceType", p.announceType)
}, func(recv keyValueMap) error {
var (
@ -640,46 +600,36 @@ func (p *serverPeer) Handshake(genesis common.Hash, forkid forkid.ID, forkFilter
rNum uint64
rTd *big.Int
)
if err := recv.get("headTd", &rTd); err != nil {
return err
}
if err := recv.get("headHash", &rHash); err != nil {
return err
}
if err := recv.get("headNum", &rNum); err != nil {
return err
}
p.headInfo = blockInfo{Hash: rHash, Number: rNum, Td: rTd}
if recv.get("serveChainSince", &p.chainSince) != nil {
p.onlyAnnounce = true
}
if recv.get("serveRecentChain", &p.chainRecent) != nil {
p.chainRecent = 0
}
if recv.get("serveStateSince", &p.stateSince) != nil {
p.onlyAnnounce = true
}
if recv.get("serveRecentState", &p.stateRecent) != nil {
p.stateRecent = 0
}
if recv.get("txRelay", nil) != nil {
p.onlyAnnounce = true
}
if p.version >= lpv4 {
var recentTx uint
if err := recv.get("recentTxLookup", &recentTx); err != nil {
return err
}
p.txHistory = uint64(recentTx)
} else {
// The weak assumption is held here that legacy les server(les2,3)
@ -687,7 +637,6 @@ func (p *serverPeer) Handshake(genesis common.Hash, forkid forkid.ID, forkFilter
// versions is disabled if the transaction is unindexed.
p.txHistory = txIndexUnlimited
}
if p.onlyAnnounce && !p.trusted {
return errResp(ErrUselessPeer, "peer cannot serve requests")
}
@ -696,16 +645,13 @@ func (p *serverPeer) Handshake(genesis common.Hash, forkid forkid.ID, forkFilter
if err := recv.get("flowControl/BL", &sParams.BufLimit); err != nil {
return err
}
if err := recv.get("flowControl/MRR", &sParams.MinRecharge); err != nil {
return err
}
var MRC RequestCostList
if err := recv.get("flowControl/MRC", &MRC); err != nil {
return err
}
p.fcParams = sParams
p.fcServer = flowcontrol.NewServerNode(sParams, &mclock.System{})
p.fcCosts = MRC.decode(ProtocolLengths[uint(p.version)])
@ -717,7 +663,6 @@ func (p *serverPeer) Handshake(genesis common.Hash, forkid forkid.ID, forkFilter
}
}
}
return nil
})
}
@ -726,7 +671,6 @@ func (p *serverPeer) Handshake(genesis common.Hash, forkid forkid.ID, forkFilter
// references should be removed upon disconnection by setValueTracker(nil, nil).
func (p *serverPeer) setValueTracker(nvt *vfc.NodeValueTracker) {
p.vtLock.Lock()
p.nodeValueTracker = nvt
if nvt != nil {
p.sentReqs = make(map[uint64]sentReqEntry)
@ -744,9 +688,7 @@ func (p *serverPeer) updateVtParams() {
if p.nodeValueTracker == nil {
return
}
reqCosts := make([]uint64, len(requestList))
for code, costs := range p.fcCosts {
if m, ok := requestMapping[uint32(code)]; ok {
reqCosts[m.first] = costs.baseCost + costs.reqCost
@ -755,7 +697,6 @@ func (p *serverPeer) updateVtParams() {
}
}
}
p.nodeValueTracker.UpdateCosts(reqCosts)
}
@ -781,21 +722,17 @@ func (p *serverPeer) answeredRequest(id uint64) {
p.vtLock.Unlock()
return
}
e, ok := p.sentReqs[id]
delete(p.sentReqs, id)
nvt := p.nodeValueTracker
p.vtLock.Unlock()
if !ok {
return
}
var (
vtReqs [2]vfc.ServedRequest
reqCount int
)
m := requestMapping[e.reqType]
if m.rest == -1 || e.amount <= 1 {
reqCount = 1
@ -805,7 +742,6 @@ func (p *serverPeer) answeredRequest(id uint64) {
vtReqs[0] = vfc.ServedRequest{ReqType: uint32(m.first), Amount: 1}
vtReqs[1] = vfc.ServedRequest{ReqType: uint32(m.rest), Amount: e.amount - 1}
}
dt := time.Duration(mclock.Now() - e.at)
nvt.Served(vtReqs[:reqCount], dt)
}
@ -866,7 +802,6 @@ func (p *clientPeer) FreeClientId() string {
return addr.IP.String()
}
}
return p.id
}
@ -890,29 +825,23 @@ func (p *clientPeer) freeze() {
// its frozen status permanently
p.frozen.Store(true)
p.Peer.Disconnect(p2p.DiscUselessPeer)
return
}
if atomic.SwapUint32(&p.frozen, 1) == 0 {
if !p.frozen.Swap(true) {
go func() {
p.sendStop()
time.Sleep(freezeTimeBase + time.Duration(rand.Int63n(int64(freezeTimeRandom))))
for {
bufValue, bufLimit := p.fcClient.BufferStatus()
if bufLimit == 0 {
return
}
if bufValue <= bufLimit/8 {
time.Sleep(freezeCheckPeriod)
continue
}
atomic.StoreUint32(&p.frozen, 0)
p.frozen.Store(false)
p.sendResume(bufValue)
return
}
}()
@ -934,7 +863,6 @@ func (r *reply) send(bv uint64) error {
ReqID, BV uint64
Data rlp.RawValue
}
return p2p.Send(r.w, r.msgcode, &resp{r.reqID, bv, r.data})
}
@ -1018,18 +946,15 @@ func (p *clientPeer) UpdateCapacity(newCap uint64, requested bool) {
if newCap != p.fcParams.MinRecharge {
p.fcParams = flowcontrol.ServerParams{MinRecharge: newCap, BufLimit: newCap * bufLimitRatio}
p.fcClient.UpdateParams(p.fcParams)
var kvList keyValueList
kvList = kvList.add("flowControl/MRR", newCap)
kvList = kvList.add("flowControl/BL", newCap*bufLimitRatio)
p.queueSend(func() { p.sendAnnounce(announceData{Update: kvList}) })
}
if p.capacity == 0 && newCap != 0 {
p.sendLastAnnounce()
}
p.capacity = newCap
}
@ -1052,14 +977,12 @@ func (p *clientPeer) sendLastAnnounce() {
if p.lastAnnounce.Td == nil {
return
}
if p.headInfo.Td == nil || p.lastAnnounce.Td.Cmp(p.headInfo.Td) > 0 {
if !p.queueSend(func() { p.sendAnnounce(p.lastAnnounce) }) {
p.Log().Debug("Dropped announcement because queue is full", "number", p.lastAnnounce.Number, "hash", p.lastAnnounce.Hash)
} else {
p.Log().Debug("Sent announcement", "number", p.lastAnnounce.Number, "hash", p.lastAnnounce.Hash)
}
p.headInfo = blockInfo{Hash: p.lastAnnounce.Hash, Number: p.lastAnnounce.Number, Td: p.lastAnnounce.Td}
}
}
@ -1075,39 +998,29 @@ func (p *clientPeer) Handshake(td *big.Int, head common.Hash, headNum uint64, ge
recentTx -= blockSafetyMargin - txIndexRecentOffset
}
}
if server.config.UltraLightOnlyAnnounce {
recentTx = txIndexDisabled
}
if recentTx != txIndexUnlimited && p.version < lpv4 {
return errors.New("Cannot serve old clients without a complete tx index")
}
// Note: clientPeer.headInfo should contain the last head announced to the client by us.
// The values announced in the handshake are dummy values for compatibility reasons and should be ignored.
p.headInfo = blockInfo{Hash: head, Number: headNum, Td: td}
return p.handshake(td, head, headNum, genesis, forkID, forkFilter, func(lists *keyValueList) {
// Add some information which services server can offer.
*lists = (*lists).add("serveHeaders", nil)
*lists = (*lists).add("serveChainSince", uint64(0))
*lists = (*lists).add("serveStateSince", uint64(0))
// If local ethereum node is running in archive mode, advertise ourselves we have
// all version state data. Otherwise only recent state is available.
stateRecent := core.DefaultCacheConfig.TriesInMemory - blockSafetyMargin
if server.archiveMode {
stateRecent = 0
}
*lists = (*lists).add("serveRecentState", stateRecent)
*lists = (*lists).add("txRelay", nil)
// If local ethereum node is running in archive mode, advertise ourselves we have
// all version state data. Otherwise only recent state is available.
stateRecent := uint64(core.DefaultCacheConfig.TriesInMemory - blockSafetyMargin)
if server.archiveMode {
stateRecent = 0
}
*lists = (*lists).add("serveRecentState", stateRecent)
*lists = (*lists).add("txRelay", nil)
if p.version >= lpv4 {
*lists = (*lists).add("recentTxLookup", recentTx)
}
*lists = (*lists).add("flowControl/BL", server.defParams.BufLimit)
*lists = (*lists).add("flowControl/MRR", server.defParams.MinRecharge)
@ -1117,7 +1030,6 @@ func (p *clientPeer) Handshake(td *big.Int, head common.Hash, headNum uint64, ge
} else {
costList = server.costTracker.makeCostList(server.costTracker.globalFactor())
}
*lists = (*lists).add("flowControl/MRC", costList)
p.fcCosts = costList.decode(ProtocolLengths[uint(p.version)])
p.fcParams = server.defParams
@ -1131,7 +1043,6 @@ func (p *clientPeer) Handshake(td *big.Int, head common.Hash, headNum uint64, ge
p.announceType = announceTypeSimple
}
}
return nil
})
}
@ -1145,7 +1056,6 @@ func (p *clientPeer) bumpInvalid() {
func (p *clientPeer) getInvalid() uint64 {
p.invalidLock.RLock()
defer p.invalidLock.RUnlock()
return p.invalidCount.Value(mclock.Now())
}
@ -1199,16 +1109,13 @@ func (ps *serverPeerSet) register(peer *serverPeer) error {
if ps.closed {
return errClosed
}
if _, exist := ps.peers[peer.id]; exist {
return errAlreadyRegistered
}
ps.peers[peer.id] = peer
for _, sub := range ps.subscribers {
sub.registerPeer(peer)
}
return nil
}
@ -1223,15 +1130,11 @@ func (ps *serverPeerSet) unregister(id string) error {
if !ok {
return errNotRegistered
}
delete(ps.peers, id)
for _, sub := range ps.subscribers {
sub.unregisterPeer(p)
}
p.Peer.Disconnect(p2p.DiscRequested)
return nil
}
@ -1244,7 +1147,6 @@ func (ps *serverPeerSet) ids() []string {
for id := range ps.peers {
ids = append(ids, id)
}
return ids
}
@ -1273,7 +1175,6 @@ func (ps *serverPeerSet) allPeers() []*serverPeer {
for _, p := range ps.peers {
list = append(list, p)
}
return list
}
@ -1286,7 +1187,6 @@ func (ps *serverPeerSet) close() {
for _, p := range ps.peers {
p.Disconnect(p2p.DiscQuitting)
}
ps.closed = true
}
@ -1315,14 +1215,11 @@ func (ps *clientPeerSet) register(peer *clientPeer) error {
if ps.closed {
return errClosed
}
if _, exist := ps.peers[peer.ID()]; exist {
return errAlreadyRegistered
}
ps.peers[peer.ID()] = peer
ps.announceOrStore(peer)
return nil
}
@ -1337,10 +1234,8 @@ func (ps *clientPeerSet) unregister(id enode.ID) error {
if !ok {
return errNotRegistered
}
delete(ps.peers, id)
p.Peer.Disconnect(p2p.DiscRequested)
return nil
}
@ -1353,7 +1248,6 @@ func (ps *clientPeerSet) ids() []enode.ID {
for id := range ps.peers {
ids = append(ids, id)
}
return ids
}
@ -1388,7 +1282,6 @@ func (ps *clientPeerSet) announceOrStore(p *clientPeer) {
if ps.lastAnnounce.Td == nil {
return
}
switch p.announceType {
case announceTypeSimple:
p.announceOrStore(ps.lastAnnounce)
@ -1397,7 +1290,6 @@ func (ps *clientPeerSet) announceOrStore(p *clientPeer) {
ps.signedAnnounce = ps.lastAnnounce
ps.signedAnnounce.sign(ps.privateKey)
}
p.announceOrStore(ps.signedAnnounce)
}
}
@ -1411,7 +1303,6 @@ func (ps *clientPeerSet) close() {
for _, p := range ps.peers {
p.Peer.Disconnect(p2p.DiscQuitting)
}
ps.closed = true
}
@ -1437,13 +1328,10 @@ func (s *serverSet) register(peer *clientPeer) error {
if s.closed {
return errClosed
}
if _, exist := s.set[peer.id]; exist {
return errAlreadyRegistered
}
s.set[peer.id] = peer
return nil
}
@ -1454,14 +1342,11 @@ func (s *serverSet) unregister(peer *clientPeer) error {
if s.closed {
return errClosed
}
if _, exist := s.set[peer.id]; !exist {
return errNotRegistered
}
delete(s.set, peer.id)
peer.Peer.Disconnect(p2p.DiscQuitting)
return nil
}
@ -1472,6 +1357,5 @@ func (s *serverSet) close() {
for _, p := range s.set {
p.Peer.Disconnect(p2p.DiscQuitting)
}
s.closed = true
}

5
les/peer_test.go
View file

@ -58,10 +58,8 @@ func TestPeerSubscription(t *testing.T) {
if len(given) == 0 && len(expect) == 0 {
return
}
sort.Strings(given)
sort.Strings(expect)
if !reflect.DeepEqual(given, expect) {
t.Fatalf("all peer ids mismatch, want %v, given %v", expect, given)
}
@ -78,7 +76,6 @@ func TestPeerSubscription(t *testing.T) {
case <-time.NewTimer(10 * time.Millisecond).C:
}
}
checkIds([]string{})
sub := newTestServerPeerSub()
@ -86,7 +83,6 @@ func TestPeerSubscription(t *testing.T) {
// Generate a random id and create the peer
var id enode.ID
rand.Read(id[:])
peer := newServerPeer(2, NetworkId, false, p2p.NewPeer(id, "name", nil), nil)
peers.register(peer)
@ -113,7 +109,6 @@ func TestHandshake(t *testing.T) {
// Generate a random id and create the peer
var id enode.ID
rand.Read(id[:])
peer1 := newClientPeer(2, NetworkId, p2p.NewPeer(id, "name", nil), net)

11
les/protocol.go
View file

@ -174,7 +174,6 @@ var (
// service vector indices.
func init() {
requestMapping = make(map[uint32]reqMapping)
for code, req := range requests {
cost := reqAvgTimeCost[code]
rm := reqMapping{len(requestList), -1}
@ -183,7 +182,6 @@ func init() {
InitAmount: req.refBasketFirst,
InitValue: float64(cost.baseCost + cost.reqCost),
})
if req.refBasketRest != 0 {
rm.rest = len(requestList)
requestList = append(requestList, vfc.RequestInfo{
@ -192,7 +190,6 @@ func init() {
InitValue: float64(cost.reqCost),
})
}
requestMapping[uint32(code)] = rm
}
}
@ -255,7 +252,6 @@ func (a *announceData) sanityCheck() error {
if tdlen := a.Td.BitLen(); tdlen > 100 {
return fmt.Errorf("too large block TD: bitlen %d", tdlen)
}
return nil
}
@ -272,18 +268,14 @@ func (a *announceData) checkSignature(id enode.ID, update keyValueMap) error {
if err := update.get("sign", &sig); err != nil {
return err
}
rlp, _ := rlp.EncodeToBytes(blockInfo{a.Hash, a.Number, a.Td})
recPubkey, err := crypto.SigToPub(crypto.Keccak256(rlp), sig)
if err != nil {
return err
}
if id == enode.PubkeyToIDV4(recPubkey) {
return nil
}
return errors.New("wrong signature")
}
@ -305,11 +297,9 @@ func (hn *hashOrNumber) EncodeRLP(w io.Writer) error {
if hn.Hash == (common.Hash{}) {
return rlp.Encode(w, hn.Number)
}
if hn.Number != 0 {
return fmt.Errorf("both origin hash (%x) and number (%d) provided", hn.Hash, hn.Number)
}
return rlp.Encode(w, hn.Hash)
}
@ -317,7 +307,6 @@ func (hn *hashOrNumber) EncodeRLP(w io.Writer) error {
// into either a block hash or a block number.
func (hn *hashOrNumber) DecodeRLP(s *rlp.Stream) error {
_, size, err := s.Kind()
switch {
case err != nil:
return err

10
les/request_test.go
View file

@ -65,7 +65,6 @@ func tfTrieEntryAccess(db ethdb.Database, bhash common.Hash, number uint64) ligh
if number := rawdb.ReadHeaderNumber(db, bhash); number != nil {
return &light.TrieRequest{Id: light.StateTrieID(rawdb.ReadHeader(db, bhash, *number)), Key: testBankSecureTrieKey}
}
return nil
}
@ -78,15 +77,12 @@ func tfCodeAccess(db ethdb.Database, bhash common.Hash, num uint64) light.OdrReq
if number != nil {
return nil
}
header := rawdb.ReadHeader(db, bhash, *number)
if header.Number.Uint64() < testContractDeployed {
return nil
}
sti := light.StateTrieID(header)
ci := light.StorageTrieID(sti, crypto.Keccak256Hash(testContractAddr[:]), common.Hash{})
ci := light.StorageTrieID(sti, testContractAddr, types.EmptyRootHash)
return &light.CodeRequest{Id: ci, Hash: crypto.Keccak256Hash(testContractCodeDeployed)}
}
@ -99,7 +95,6 @@ func testAccess(t *testing.T, protocol int, fn accessTestFn) {
connect: true,
nopruning: true,
}
server, client, tearDown := newClientServerEnv(t, netconfig)
defer tearDown()
@ -116,16 +111,13 @@ func testAccess(t *testing.T, protocol int, fn accessTestFn) {
ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
err := client.handler.backend.odr.Retrieve(ctx, req)
cancel()
got := err == nil
exp := i < expFail
if exp && !got {
t.Errorf("object retrieval failed")
}
if !exp && got {
t.Errorf("unexpected object retrieval success")
}

36
les/retrieve.go
View file

@ -112,7 +112,6 @@ func (rm *retrieveManager) retrieve(ctx context.Context, reqID uint64, req *dist
case <-shutdown:
sentReq.stop(errors.New("client is shutting down"))
}
return sentReq.getError()
}
@ -135,7 +134,6 @@ func (rm *retrieveManager) sendReq(reqID uint64, req *distReq, val validatorFunc
r.lock.RLock()
_, sent := r.sentTo[p]
r.lock.RUnlock()
return !sent && canSend(p)
}
@ -145,29 +143,16 @@ func (rm *retrieveManager) sendReq(reqID uint64, req *distReq, val validatorFunc
r.lock.Lock()
r.sentTo[p] = sentReqToPeer{delivered: false, frozen: false, event: make(chan int, 1)}
r.lock.Unlock()
return request(p)
}
rm.lock.Lock()
rm.sentReqs[reqID] = r
rm.lock.Unlock()
go r.retrieveLoop()
return r
}
// requested reports whether the request with given reqid is sent by the retriever.
func (rm *retrieveManager) requested(reqId uint64) bool {
rm.lock.RLock()
defer rm.lock.RUnlock()
_, ok := rm.sentReqs[reqId]
return ok
}
// deliver is called by the LES protocol manager to deliver reply messages to waiting requests
func (rm *retrieveManager) deliver(peer distPeer, msg *Msg) error {
rm.lock.RLock()
@ -177,7 +162,6 @@ func (rm *retrieveManager) deliver(peer distPeer, msg *Msg) error {
if ok {
return req.deliver(peer, msg)
}
return errResp(ErrUnexpectedResponse, "reqID = %v", msg.ReqID)
}
@ -216,7 +200,6 @@ func (r *sentReq) stateRequesting() reqStateFn {
select {
case ev := <-r.eventsCh:
r.update(ev)
switch ev.event {
case rpSent:
if ev.peer == nil {
@ -234,7 +217,6 @@ func (r *sentReq) stateRequesting() reqStateFn {
// last request timed out, try asking a new peer
go r.tryRequest()
r.lastReqQueued = true
return r.stateRequesting
case rpDeliveredInvalid, rpNotDelivered:
// if it was the last sent request (set to nil by update) then start a new one
@ -242,13 +224,11 @@ func (r *sentReq) stateRequesting() reqStateFn {
go r.tryRequest()
r.lastReqQueued = true
}
return r.stateRequesting
case rpDeliveredValid:
r.stop(nil)
return r.stateStopped
}
return r.stateRequesting
case <-r.stopCh:
return r.stateStopped
@ -263,22 +243,17 @@ func (r *sentReq) stateNoMorePeers() reqStateFn {
case <-time.After(retryQueue):
go r.tryRequest()
r.lastReqQueued = true
return r.stateRequesting
case ev := <-r.eventsCh:
r.update(ev)
if ev.event == rpDeliveredValid {
r.stop(nil)
return r.stateStopped
}
if r.waiting() {
return r.stateNoMorePeers
}
r.stop(light.ErrNoPeers)
return nil
case <-r.stopCh:
return r.stateStopped
@ -291,7 +266,6 @@ func (r *sentReq) stateStopped() reqStateFn {
for r.waiting() {
r.update(<-r.eventsCh)
}
return nil
}
@ -326,7 +300,6 @@ func (r *sentReq) waiting() bool {
// messages to the request's event channel.
func (r *sentReq) tryRequest() {
sent := r.rm.dist.queue(r.req)
var p distPeer
select {
case p = <-sent:
@ -339,7 +312,6 @@ func (r *sentReq) tryRequest() {
}
r.eventsCh <- reqPeerEvent{rpSent, p}
if p == nil {
return
}
@ -349,7 +321,6 @@ func (r *sentReq) tryRequest() {
r.lock.RLock()
s, ok := r.sentTo[p]
r.lock.RUnlock()
if !ok {
panic(nil)
}
@ -358,7 +329,6 @@ func (r *sentReq) tryRequest() {
pp, ok := p.(*serverPeer)
if hrto && ok {
pp.Log().Debug("Request timed out hard")
if r.rm.peers != nil {
r.rm.peers.unregister(pp.id)
}
@ -373,7 +343,6 @@ func (r *sentReq) tryRequest() {
r.lock.Unlock()
}
r.eventsCh <- reqPeerEvent{event, p}
return
case <-time.After(r.rm.softRequestTimeout()):
r.eventsCh <- reqPeerEvent{rpSoftTimeout, p}
@ -402,24 +371,19 @@ func (r *sentReq) deliver(peer distPeer, msg *Msg) error {
if !ok || s.delivered {
return errResp(ErrUnexpectedResponse, "reqID = %v", msg.ReqID)
}
if s.frozen {
return nil
}
valid := r.validate(peer, msg) == nil
r.sentTo[peer] = sentReqToPeer{delivered: true, frozen: false, event: s.event}
if valid {
s.event <- rpDeliveredValid
} else {
s.event <- rpDeliveredInvalid
}
if !valid {
return errResp(ErrInvalidResponse, "reqID = %v", msg.ReqID)
}
return nil
}

29
les/server.go
View file

@ -88,7 +88,6 @@ func NewLesServer(node *node.Node, e ethBackend, config *ethconfig.Config) (*Les
if threads < 4 {
threads = 4
}
srv := &LesServer{
lesCommons: lesCommons{
genesis: e.BlockChain().Genesis().Hash(),
@ -112,12 +111,10 @@ func NewLesServer(node *node.Node, e ethBackend, config *ethconfig.Config) (*Les
threadsIdle: threads,
p2pSrv: node.Server(),
}
issync := e.Synced
if config.LightNoSyncServe {
issync = func() bool { return true }
}
srv.handler = newServerHandler(srv, e.BlockChain(), e.ChainDb(), e.TxPool(), issync)
srv.costTracker, srv.minCapacity = newCostTracker(e.ChainDb(), config)
@ -136,29 +133,19 @@ func NewLesServer(node *node.Node, e ethBackend, config *ethconfig.Config) (*Les
// possible while the actually used server capacity does not exceed the limits
totalRecharge := srv.costTracker.totalRecharge()
srv.maxCapacity = srv.minCapacity * uint64(srv.config.LightPeers)
if totalRecharge > srv.maxCapacity {
srv.maxCapacity = totalRecharge
}
srv.fcManager.SetCapacityLimits(srv.minCapacity, srv.maxCapacity, srv.minCapacity*2)
srv.clientPool = vfs.NewClientPool(lesDb, srv.minCapacity, defaultConnectedBias, mclock.System{}, issync)
srv.clientPool.Start()
srv.clientPool.SetDefaultFactors(defaultPosFactors, defaultNegFactors)
srv.vfluxServer.Register(srv.clientPool, "les", "Ethereum light client service")
checkpoint := srv.latestLocalCheckpoint()
if !checkpoint.Empty() {
log.Info("Loaded latest checkpoint", "section", checkpoint.SectionIndex, "head", checkpoint.SectionHead,
"chtroot", checkpoint.CHTRoot, "bloomroot", checkpoint.BloomRoot)
}
srv.chtIndexer.Start(e.BlockChain())
node.RegisterProtocols(srv.Protocols())
node.RegisterAPIs(srv.APIs())
node.RegisterLifecycle(srv)
return srv, nil
}
@ -180,7 +167,6 @@ func (s *LesServer) Protocols() []p2p.Protocol {
if p := s.peers.peer(id); p != nil {
return p.Info()
}
return nil
}, nil)
// Add "les" ENR entries.
@ -189,7 +175,6 @@ func (s *LesServer) Protocols() []p2p.Protocol {
VfxVersion: 1,
}}
}
return ps
}
@ -199,13 +184,10 @@ func (s *LesServer) Start() error {
s.peers.setSignerKey(s.privateKey)
s.handler.start()
s.wg.Add(1)
go s.capacityManagement()
if s.p2pSrv.DiscV5 != nil {
s.p2pSrv.DiscV5.RegisterTalkHandler("vfx", s.vfluxServer.ServeEncoded)
}
return nil
}
@ -214,17 +196,14 @@ func (s *LesServer) Stop() error {
close(s.closeCh)
s.clientPool.Stop()
if s.serverset != nil {
s.serverset.close()
}
s.peers.close()
s.fcManager.Stop()
s.costTracker.stop()
s.handler.stop()
s.servingQueue.stop()
if s.vfluxServer != nil {
s.vfluxServer.Stop()
}
@ -233,11 +212,9 @@ func (s *LesServer) Stop() error {
if s.chtIndexer != nil {
s.chtIndexer.Close()
}
if s.lesDb != nil {
s.lesDb.Close()
}
s.wg.Wait()
log.Info("Les server stopped")
@ -251,7 +228,6 @@ func (s *LesServer) capacityManagement() {
defer s.wg.Done()
processCh := make(chan bool, 100)
sub := s.handler.blockchain.SubscribeBlockProcessingEvent(processCh)
defer sub.Unsubscribe()
@ -267,7 +243,6 @@ func (s *LesServer) capacityManagement() {
freePeers uint64
blockProcess mclock.AbsTime
)
updateRecharge := func() {
if busy {
s.servingQueue.setThreads(s.threadsBusy)
@ -287,21 +262,17 @@ func (s *LesServer) capacityManagement() {
} else {
blockProcessingTimer.Update(time.Duration(mclock.Now() - blockProcess))
}
updateRecharge()
case totalRecharge = <-totalRechargeCh:
totalRechargeGauge.Update(int64(totalRecharge))
updateRecharge()
case totalCapacity = <-totalCapacityCh:
totalCapacityGauge.Update(int64(totalCapacity))
newFreePeers := totalCapacity / s.minCapacity
if newFreePeers < freePeers && newFreePeers < uint64(s.config.LightPeers) {
log.Warn("Reduced free peer connections", "from", freePeers, "to", newFreePeers)
}
freePeers = newFreePeers
s.clientPool.SetLimits(uint64(s.config.LightPeers), totalCapacity)
case <-s.closeCh:
return

54
les/server_handler.go
View file

@ -18,6 +18,7 @@ package les
import (
"errors"
"fmt"
"sync"
"time"
@ -34,7 +35,6 @@ import (
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/metrics"
"github.com/ethereum/go-ethereum/p2p"
"github.com/ethereum/go-ethereum/rlp"
"github.com/ethereum/go-ethereum/trie"
)
@ -83,7 +83,6 @@ func newServerHandler(server *LesServer, blockchain *core.BlockChain, chainDb et
closeCh: make(chan struct{}),
synced: synced,
}
return handler
}
@ -104,9 +103,7 @@ func (h *serverHandler) runPeer(version uint, p *p2p.Peer, rw p2p.MsgReadWriter)
peer := newClientPeer(int(version), h.server.config.NetworkId, p, newMeteredMsgWriter(rw, int(version)))
defer peer.close()
h.wg.Add(1)
defer h.wg.Done()
return h.handle(peer)
}
@ -121,7 +118,6 @@ func (h *serverHandler) handle(p *clientPeer) error {
td = h.blockchain.GetTd(hash, number)
forkID = forkid.NewID(h.blockchain.Config(), h.blockchain.Genesis().Hash(), number, head.Time)
)
if err := p.Handshake(td, hash, number, h.blockchain.Genesis().Hash(), forkID, h.forkFilter, h.server); err != nil {
p.Log().Debug("Light Ethereum handshake failed", "err", err)
return err
@ -131,10 +127,8 @@ func (h *serverHandler) handle(p *clientPeer) error {
if err := h.server.serverset.register(p); err != nil {
return err
}
_, err := p.rw.ReadMsg()
h.server.serverset.unregister(p)
return err
}
// Setup flow control mechanism for the peer
@ -152,14 +146,11 @@ func (h *serverHandler) handle(p *clientPeer) error {
if err := h.server.peers.register(p); err != nil {
return err
}
if p.balance = h.server.clientPool.Register(p); p.balance == nil {
h.server.peers.unregister(p.ID())
p.Log().Debug("Client pool already closed")
return p2p.DiscRequested
}
p.connectedAt = mclock.Now()
var wg sync.WaitGroup // Wait group used to track all in-flight task routines.
@ -183,7 +174,6 @@ func (h *serverHandler) handle(p *clientPeer) error {
return err
default:
}
if err := h.handleMsg(p, &wg); err != nil {
p.Log().Debug("Light Ethereum message handling failed", "err", err)
return err
@ -205,15 +195,12 @@ func (h *serverHandler) beforeHandle(p *clientPeer, reqID, responseCount uint64,
p.fcClient.OneTimeCost(inSizeCost)
return nil, 0
}
maxCost := p.fcCosts.getMaxCost(msg.Code, reqCnt)
accepted, bufShort, priority := p.fcClient.AcceptRequest(reqID, responseCount, maxCost)
if !accepted {
p.freeze()
p.Log().Error("Request came too early", "remaining", common.PrettyDuration(time.Duration(bufShort*1000000/p.fcParams.MinRecharge)))
p.fcClient.OneTimeCost(inSizeCost)
return nil, 0
}
// Create a multi-stage task, estimate the time it takes for the task to
@ -223,15 +210,12 @@ func (h *serverHandler) beforeHandle(p *clientPeer, reqID, responseCount uint64,
factor = 1
p.Log().Error("Invalid global cost factor", "factor", factor)
}
maxTime := uint64(float64(maxCost) / factor)
task := h.server.servingQueue.newTask(p, maxTime, priority)
if !task.start() {
p.fcClient.RequestProcessed(reqID, responseCount, maxCost, inSizeCost)
return nil, 0
}
return task, maxCost
}
@ -241,7 +225,6 @@ func (h *serverHandler) afterHandle(p *clientPeer, reqID, responseCount uint64,
if reply != nil {
task.done()
}
p.responseLock.Lock()
defer p.responseLock.Unlock()
@ -249,7 +232,6 @@ func (h *serverHandler) afterHandle(p *clientPeer, reqID, responseCount uint64,
if p.isFrozen() {
realCost := h.server.costTracker.realCost(task.servingTime, msg.Size, 0)
p.fcClient.RequestProcessed(reqID, responseCount, maxCost, realCost)
return
}
// Positive correction buffer value with real cost.
@ -257,7 +239,6 @@ func (h *serverHandler) afterHandle(p *clientPeer, reqID, responseCount uint64,
if reply != nil {
replySize = reply.size()
}
var realCost uint64
if h.server.costTracker.testing {
realCost = maxCost // Assign a fake cost for testing purpose
@ -267,9 +248,7 @@ func (h *serverHandler) afterHandle(p *clientPeer, reqID, responseCount uint64,
realCost = maxCost
}
}
bv := p.fcClient.RequestProcessed(reqID, responseCount, maxCost, realCost)
if reply != nil {
// Feed cost tracker request serving statistic.
h.server.costTracker.updateStats(msg.Code, reqCnt, task.servingTime, realCost)
@ -294,7 +273,6 @@ func (h *serverHandler) handleMsg(p *clientPeer, wg *sync.WaitGroup) error {
if err != nil {
return err
}
p.Log().Trace("Light Ethereum message arrived", "code", msg.Code, "bytes", msg.Size)
// Discard large message which exceeds the limitation.
@ -310,10 +288,8 @@ func (h *serverHandler) handleMsg(p *clientPeer, wg *sync.WaitGroup) error {
if !ok {
p.Log().Trace("Received invalid message", "code", msg.Code)
clientErrorMeter.Mark(1)
return errResp(ErrInvalidMsgCode, "%v", msg.Code)
}
p.Log().Trace("Received " + req.Name)
// Decode the p2p message, resolve the concrete handler for it.
@ -322,12 +298,10 @@ func (h *serverHandler) handleMsg(p *clientPeer, wg *sync.WaitGroup) error {
clientErrorMeter.Mark(1)
return errResp(ErrDecode, "%v: %v", msg, err)
}
if metrics.EnabledExpensive {
req.InPacketsMeter.Mark(1)
req.InTrafficMeter.Mark(int64(msg.Size))
}
p.responseCount++
responseCount := p.responseCount
@ -337,9 +311,7 @@ func (h *serverHandler) handleMsg(p *clientPeer, wg *sync.WaitGroup) error {
if task == nil {
return nil
}
wg.Add(1)
go func() {
defer wg.Done()
@ -351,7 +323,6 @@ func (h *serverHandler) handleMsg(p *clientPeer, wg *sync.WaitGroup) error {
if reply != nil {
size = reply.size()
}
req.OutPacketsMeter.Mark(1)
req.OutTrafficMeter.Mark(int64(size))
req.ServingTimeMeter.Update(time.Duration(task.servingTime))
@ -363,7 +334,6 @@ func (h *serverHandler) handleMsg(p *clientPeer, wg *sync.WaitGroup) error {
clientErrorMeter.Mark(1)
return errTooManyInvalidRequest
}
return nil
}
@ -393,18 +363,14 @@ func getAccount(triedb *trie.Database, root common.Hash, addr common.Address) (t
if err != nil {
return types.StateAccount{}, err
}
blob, err := trie.Get(hash[:])
acc, err := trie.GetAccount(addr)
if err != nil {
return types.StateAccount{}, err
}
var acc types.StateAccount
if err = rlp.DecodeBytes(blob, &acc); err != nil {
return types.StateAccount{}, err
if acc == nil {
return types.StateAccount{}, fmt.Errorf("account %#x is not present", addr)
}
return acc, nil
return *acc, nil
}
// GetHelperTrie returns the post-processed trie root for the given trie ID and section index
@ -413,7 +379,6 @@ func (h *serverHandler) GetHelperTrie(typ uint, index uint64) *trie.Trie {
root common.Hash
prefix string
)
switch typ {
case htCanonical:
sectionHead := rawdb.ReadCanonicalHash(h.chainDb, (index+1)*h.server.iConfig.ChtSize-1)
@ -422,13 +387,10 @@ func (h *serverHandler) GetHelperTrie(typ uint, index uint64) *trie.Trie {
sectionHead := rawdb.ReadCanonicalHash(h.chainDb, (index+1)*h.server.iConfig.BloomTrieSize-1)
root, prefix = light.GetBloomTrieRoot(h.chainDb, index, sectionHead), string(rawdb.BloomTrieTablePrefix)
}
if root == (common.Hash{}) {
return nil
}
trie, _ := trie.New(trie.TrieID(root), trie.NewDatabase(rawdb.NewTable(h.chainDb, prefix)))
return trie
}
@ -440,7 +402,6 @@ func (h *serverHandler) broadcastLoop() {
defer h.wg.Done()
headCh := make(chan core.ChainHeadEvent, 10)
headSub := h.blockchain.SubscribeChainHeadEvent(headCh)
defer headSub.Unsubscribe()
@ -448,27 +409,22 @@ func (h *serverHandler) broadcastLoop() {
lastHead = h.blockchain.CurrentHeader()
lastTd = common.Big0
)
for {
select {
case ev := <-headCh:
header := ev.Block.Header()
hash, number := header.Hash(), header.Number.Uint64()
td := h.blockchain.GetTd(hash, number)
if td == nil || td.Cmp(lastTd) <= 0 {
continue
}
var reorg uint64
if lastHead != nil {
// If a setHead has been performed, the common ancestor can be nil.
if ancestor := rawdb.FindCommonAncestor(h.chainDb, header, lastHead); ancestor != nil {
reorg = lastHead.Number.Uint64() - ancestor.Number.Uint64()
}
}
lastHead, lastTd = header, td
log.Debug("Announcing block to peers", "number", number, "hash", hash, "td", td, "reorg", reorg)
h.server.peers.broadcast(announceData{Hash: hash, Number: number, Td: td, ReorgDepth: reorg})

78
les/server_requests.go
View file

@ -154,7 +154,6 @@ func handleGetBlockHeaders(msg Decoder) (serveRequestFn, uint64, uint64, error)
if err := msg.Decode(&r); err != nil {
return nil, 0, 0, err
}
return func(backend serverBackend, p *clientPeer, waitOrStop func() bool) *reply {
// Gather headers until the fetch or network limits is reached
var (
@ -166,14 +165,12 @@ func handleGetBlockHeaders(msg Decoder) (serveRequestFn, uint64, uint64, error)
headers []*types.Header
unknown bool
)
for !unknown && len(headers) < int(r.Query.Amount) && bytes < softResponseLimit {
if !first && !waitOrStop() {
return nil
}
// Retrieve the next header satisfying the r
var origin *types.Header
if hashMode {
if first {
origin = bc.GetHeaderByHash(r.Query.Origin.Hash)
@ -186,11 +183,9 @@ func handleGetBlockHeaders(msg Decoder) (serveRequestFn, uint64, uint64, error)
} else {
origin = bc.GetHeaderByNumber(r.Query.Origin.Number)
}
if origin == nil {
break
}
headers = append(headers, origin)
bytes += estHeaderRlpSize
@ -211,17 +206,14 @@ func handleGetBlockHeaders(msg Decoder) (serveRequestFn, uint64, uint64, error)
current = origin.Number.Uint64()
next = current + r.Query.Skip + 1
)
if next <= current {
infos, _ := json.Marshal(p.Peer.Info())
p.Log().Warn("GetBlockHeaders skip overflow attack", "current", current, "skip", r.Query.Skip, "next", next, "attacker", string(infos))
unknown = true
} else {
if header := bc.GetHeaderByNumber(next); header != nil {
nextHash := header.Hash()
expOldHash, _ := bc.GetAncestor(nextHash, next, r.Query.Skip+1, &maxNonCanonical)
if expOldHash == r.Query.Origin.Hash {
r.Query.Origin.Hash, r.Query.Origin.Number = nextHash, next
} else {
@ -243,10 +235,8 @@ func handleGetBlockHeaders(msg Decoder) (serveRequestFn, uint64, uint64, error)
// Number based traversal towards the leaf block
r.Query.Origin.Number += r.Query.Skip + 1
}
first = false
}
return p.replyBlockHeaders(r.ReqID, headers)
}, r.ReqID, r.Query.Amount, nil
}
@ -257,34 +247,27 @@ func handleGetBlockBodies(msg Decoder) (serveRequestFn, uint64, uint64, error) {
if err := msg.Decode(&r); err != nil {
return nil, 0, 0, err
}
return func(backend serverBackend, p *clientPeer, waitOrStop func() bool) *reply {
var (
bytes int
bodies []rlp.RawValue
)
bc := backend.BlockChain()
for i, hash := range r.Hashes {
if i != 0 && !waitOrStop() {
return nil
}
if bytes >= softResponseLimit {
break
}
body := bc.GetBodyRLP(hash)
if body == nil {
p.bumpInvalid()
continue
}
bodies = append(bodies, body)
bytes += len(body)
}
return p.replyBlockBodiesRLP(r.ReqID, bodies)
}, r.ReqID, uint64(len(r.Hashes)), nil
}
@ -295,15 +278,12 @@ func handleGetCode(msg Decoder) (serveRequestFn, uint64, uint64, error) {
if err := msg.Decode(&r); err != nil {
return nil, 0, 0, err
}
return func(backend serverBackend, p *clientPeer, waitOrStop func() bool) *reply {
var (
bytes int
data [][]byte
)
bc := backend.BlockChain()
for i, request := range r.Reqs {
if i != 0 && !waitOrStop() {
return nil
@ -313,7 +293,6 @@ func handleGetCode(msg Decoder) (serveRequestFn, uint64, uint64, error) {
if header == nil {
p.Log().Warn("Failed to retrieve associate header for code", "hash", request.BHash)
p.bumpInvalid()
continue
}
// Refuse to search stale state data in the database since looking for
@ -322,33 +301,27 @@ func handleGetCode(msg Decoder) (serveRequestFn, uint64, uint64, error) {
if !backend.ArchiveMode() && header.Number.Uint64()+core.DefaultCacheConfig.TriesInMemory <= local {
p.Log().Debug("Reject stale code request", "number", header.Number.Uint64(), "head", local)
p.bumpInvalid()
continue
}
triedb := bc.StateCache().TrieDB()
address := common.BytesToAddress(request.AccountAddress)
account, err := getAccount(triedb, header.Root, address)
if err != nil {
p.Log().Warn("Failed to retrieve account for code", "block", header.Number, "hash", header.Hash(), "account", address, "err", err)
p.bumpInvalid()
continue
}
code, err := bc.StateCache().ContractCode(common.BytesToHash(request.AccKey), common.BytesToHash(account.CodeHash))
code, err := bc.StateCache().ContractCode(address, common.BytesToHash(account.CodeHash))
if err != nil {
p.Log().Warn("Failed to retrieve account code", "block", header.Number, "hash", header.Hash(), "account", address, "codehash", common.BytesToHash(account.CodeHash), "err", err)
continue
}
// Accumulate the code and abort if enough data was retrieved
data = append(data, code)
if bytes += len(code); bytes >= softResponseLimit {
break
}
}
return p.replyCode(r.ReqID, data)
}, r.ReqID, uint64(len(r.Reqs)), nil
}
@ -359,20 +332,16 @@ func handleGetReceipts(msg Decoder) (serveRequestFn, uint64, uint64, error) {
if err := msg.Decode(&r); err != nil {
return nil, 0, 0, err
}
return func(backend serverBackend, p *clientPeer, waitOrStop func() bool) *reply {
var (
bytes int
receipts []rlp.RawValue
)
bc := backend.BlockChain()
for i, hash := range r.Hashes {
if i != 0 && !waitOrStop() {
return nil
}
if bytes >= softResponseLimit {
break
}
@ -392,7 +361,6 @@ func handleGetReceipts(msg Decoder) (serveRequestFn, uint64, uint64, error) {
bytes += len(encoded)
}
}
return p.replyReceiptsRLP(r.ReqID, receipts)
}, r.ReqID, uint64(len(r.Hashes)), nil
}
@ -403,7 +371,6 @@ func handleGetProofs(msg Decoder) (serveRequestFn, uint64, uint64, error) {
if err := msg.Decode(&r); err != nil {
return nil, 0, 0, err
}
return func(backend serverBackend, p *clientPeer, waitOrStop func() bool) *reply {
var (
lastBHash common.Hash
@ -411,7 +378,6 @@ func handleGetProofs(msg Decoder) (serveRequestFn, uint64, uint64, error) {
header *types.Header
err error
)
bc := backend.BlockChain()
nodes := light.NewNodeSet()
@ -426,7 +392,6 @@ func handleGetProofs(msg Decoder) (serveRequestFn, uint64, uint64, error) {
if header = bc.GetHeaderByHash(request.BHash); header == nil {
p.Log().Warn("Failed to retrieve header for proof", "hash", request.BHash)
p.bumpInvalid()
continue
}
// Refuse to search stale state data in the database since looking for
@ -435,10 +400,8 @@ func handleGetProofs(msg Decoder) (serveRequestFn, uint64, uint64, error) {
if !backend.ArchiveMode() && header.Number.Uint64()+core.DefaultCacheConfig.TriesInMemory <= local {
p.Log().Debug("Reject stale trie request", "number", header.Number.Uint64(), "head", local)
p.bumpInvalid()
continue
}
root = header.Root
}
// If a header lookup failed (non existent), ignore subsequent requests for the same header
@ -450,8 +413,7 @@ func handleGetProofs(msg Decoder) (serveRequestFn, uint64, uint64, error) {
statedb := bc.StateCache()
var trie state.Trie
switch len(request.AccKey) {
switch len(request.AccountAddress) {
case 0:
// No account key specified, open an account trie
trie, err = statedb.OpenTrie(root)
@ -466,11 +428,9 @@ func handleGetProofs(msg Decoder) (serveRequestFn, uint64, uint64, error) {
if err != nil {
p.Log().Warn("Failed to retrieve account for proof", "block", header.Number, "hash", header.Hash(), "account", address, "err", err)
p.bumpInvalid()
continue
}
trie, err = statedb.OpenStorageTrie(root, common.BytesToHash(request.AccKey), account.Root)
trie, err = statedb.OpenStorageTrie(root, address, account.Root)
if trie == nil || err != nil {
p.Log().Warn("Failed to open storage trie for proof", "block", header.Number, "hash", header.Hash(), "account", address, "root", account.Root, "err", err)
continue
@ -481,12 +441,10 @@ func handleGetProofs(msg Decoder) (serveRequestFn, uint64, uint64, error) {
p.Log().Warn("Failed to prove state request", "block", header.Number, "hash", header.Hash(), "err", err)
continue
}
if nodes.DataSize() >= softResponseLimit {
break
}
}
return p.replyProofsV2(r.ReqID, nodes.NodeList())
}, r.ReqID, uint64(len(r.Reqs)), nil
}
@ -497,7 +455,6 @@ func handleGetHelperTrieProofs(msg Decoder) (serveRequestFn, uint64, uint64, err
if err := msg.Decode(&r); err != nil {
return nil, 0, 0, err
}
return func(backend serverBackend, p *clientPeer, waitOrStop func() bool) *reply {
var (
lastIdx uint64
@ -506,20 +463,16 @@ func handleGetHelperTrieProofs(msg Decoder) (serveRequestFn, uint64, uint64, err
auxBytes int
auxData [][]byte
)
bc := backend.BlockChain()
nodes := light.NewNodeSet()
for i, request := range r.Reqs {
if i != 0 && !waitOrStop() {
return nil
}
if auxTrie == nil || request.Type != lastType || request.TrieIdx != lastIdx {
lastType, lastIdx = request.Type, request.TrieIdx
auxTrie = backend.GetHelperTrie(request.Type, request.TrieIdx)
}
if auxTrie == nil {
return nil
}
@ -532,25 +485,20 @@ func handleGetHelperTrieProofs(msg Decoder) (serveRequestFn, uint64, uint64, err
if p.version >= lpv4 && err != nil {
return nil
}
if request.Type == htCanonical && request.AuxReq == htAuxHeader && len(request.Key) == 8 {
header := bc.GetHeaderByNumber(binary.BigEndian.Uint64(request.Key))
data, err := rlp.EncodeToBytes(header)
if err != nil {
log.Error("Failed to encode header", "err", err)
return nil
}
auxData = append(auxData, data)
auxBytes += len(data)
}
if nodes.DataSize()+auxBytes >= softResponseLimit {
break
}
}
return p.replyHelperTrieProofs(r.ReqID, HelperTrieResps{Proofs: nodes.NodeList(), AuxData: auxData})
}, r.ReqID, uint64(len(r.Reqs)), nil
}
@ -561,36 +509,23 @@ func handleSendTx(msg Decoder) (serveRequestFn, uint64, uint64, error) {
if err := msg.Decode(&r); err != nil {
return nil, 0, 0, err
}
amount := uint64(len(r.Txs))
return func(backend serverBackend, p *clientPeer, waitOrStop func() bool) *reply {
stats := make([]light.TxStatus, len(r.Txs))
for i, tx := range r.Txs {
if i != 0 && !waitOrStop() {
return nil
}
hash := tx.Hash()
stats[i] = txStatus(backend, hash)
if stats[i].Status == txpool.TxStatusUnknown {
addFn := backend.TxPool().AddRemotes
// Add txs synchronously for testing purpose
if backend.AddTxsSync() {
addFn = backend.TxPool().AddRemotesSync
}
if errs := addFn([]*types.Transaction{tx}); errs[0] != nil {
if errs := backend.TxPool().Add([]*txpool.Transaction{{Tx: tx}}, false, backend.AddTxsSync()); errs[0] != nil {
stats[i].Error = errs[0].Error()
continue
}
stats[i] = txStatus(backend, hash)
}
}
return p.replyTxStatus(r.ReqID, stats)
}, r.ReqID, amount, nil
}
@ -601,18 +536,14 @@ func handleGetTxStatus(msg Decoder) (serveRequestFn, uint64, uint64, error) {
if err := msg.Decode(&r); err != nil {
return nil, 0, 0, err
}
return func(backend serverBackend, p *clientPeer, waitOrStop func() bool) *reply {
stats := make([]light.TxStatus, len(r.Hashes))
for i, hash := range r.Hashes {
if i != 0 && !waitOrStop() {
return nil
}
stats[i] = txStatus(backend, hash)
}
return p.replyTxStatus(r.ReqID, stats)
}, r.ReqID, uint64(len(r.Hashes)), nil
}
@ -631,6 +562,5 @@ func txStatus(b serverBackend, hash common.Hash) light.TxStatus {
stat.Lookup = lookup
}
}
return stat
}

45
les/servingqueue.go
View file

@ -17,12 +17,12 @@
package les
import (
"sort"
"sync"
"sync/atomic"
"github.com/ethereum/go-ethereum/common/mclock"
"github.com/ethereum/go-ethereum/common/prque"
"golang.org/x/exp/slices"
)
// servingQueue allows running tasks in a limited number of threads and puts the
@ -73,7 +73,6 @@ func (t *servingTask) start() bool {
if t.peer.isFrozen() {
return false
}
t.tokenCh = make(chan runToken, 1)
select {
case t.sq.queueAddCh <- t:
@ -85,13 +84,10 @@ func (t *servingTask) start() bool {
case <-t.sq.quit:
return false
}
if t.token == nil {
return false
}
t.servingTime -= uint64(mclock.Now())
return true
}
@ -102,14 +98,12 @@ func (t *servingTask) done() uint64 {
close(t.token)
diff := t.servingTime - t.timeAdded
t.timeAdded = t.servingTime
if t.expTime > diff {
t.expTime -= diff
atomic.AddUint64(&t.sq.servingTimeDiff, t.expTime)
} else {
t.expTime = 0
}
return t.servingTime
}
@ -119,12 +113,10 @@ func (t *servingTask) done() uint64 {
// means the task should be cancelled.
func (t *servingTask) waitOrStop() bool {
t.done()
if !t.biasAdded {
t.priority += t.sq.suspendBias
t.biasAdded = true
}
return t.start()
}
@ -144,10 +136,8 @@ func newServingQueue(suspendBias int64, utilTarget float64) *servingQueue {
lastUpdate: mclock.Now(),
}
sq.wg.Add(2)
go sq.queueLoop()
go sq.threadCountLoop()
return sq
}
@ -170,7 +160,6 @@ func (sq *servingQueue) newTask(peer *clientPeer, maxTime uint64, priority int64
// without entering the priority queue.
func (sq *servingQueue) threadController() {
defer sq.wg.Done()
for {
token := make(runToken)
select {
@ -203,24 +192,19 @@ type peerTasks struct {
// them until burstTime goes under burstDropLimit or all peers are frozen
func (sq *servingQueue) freezePeers() {
peerMap := make(map[*clientPeer]*peerTasks)
var peerList peerList
var peerList []*peerTasks
if sq.best != nil {
sq.queue.Push(sq.best, sq.best.priority)
}
sq.best = nil
for sq.queue.Size() > 0 {
task := sq.queue.PopItem()
tasks := peerMap[task.peer]
if tasks == nil {
bufValue, bufLimit := task.peer.fcClient.BufferStatus()
if bufLimit < 1 {
bufLimit = 1
}
tasks = &peerTasks{
peer: task.peer,
priority: float64(bufValue) / float64(bufLimit), // lower value comes first
@ -228,12 +212,18 @@ func (sq *servingQueue) freezePeers() {
peerMap[task.peer] = tasks
peerList = append(peerList, tasks)
}
tasks.list = append(tasks.list, task)
tasks.sumTime += task.expTime
}
sort.Sort(peerList)
slices.SortFunc(peerList, func(a, b *peerTasks) int {
if a.priority < b.priority {
return -1
}
if a.priority > b.priority {
return 1
}
return 0
})
drop := true
for _, tasks := range peerList {
if drop {
@ -242,9 +232,7 @@ func (sq *servingQueue) freezePeers() {
sq.queuedTime -= tasks.sumTime
sqQueuedGauge.Update(int64(sq.queuedTime))
clientFreezeMeter.Mark(1)
drop = sq.recentTime+sq.queuedTime > sq.burstDropLimit
for _, task := range tasks.list {
task.tokenCh <- nil
}
@ -254,7 +242,6 @@ func (sq *servingQueue) freezePeers() {
}
}
}
if sq.queue.Size() > 0 {
sq.best = sq.queue.PopItem()
}
@ -266,11 +253,9 @@ func (sq *servingQueue) updateRecentTime() {
now := mclock.Now()
dt := now - sq.lastUpdate
sq.lastUpdate = now
if dt > 0 {
subTime += uint64(float64(dt) * sq.burstDecRate)
}
if sq.recentTime > subTime {
sq.recentTime -= subTime
} else {
@ -288,12 +273,10 @@ func (sq *servingQueue) addTask(task *servingTask) {
} else {
sq.queue.Push(task, task.priority)
}
sq.updateRecentTime()
sq.queuedTime += task.expTime
sqServedGauge.Update(int64(sq.recentTime))
sqQueuedGauge.Update(int64(sq.queuedTime))
if sq.recentTime+sq.queuedTime > sq.burstLimit {
sq.freezePeers()
}
@ -304,7 +287,6 @@ func (sq *servingQueue) addTask(task *servingTask) {
// tasks are removed from the queue.
func (sq *servingQueue) queueLoop() {
defer sq.wg.Done()
for {
if sq.best != nil {
expTime := sq.best.expTime
@ -317,7 +299,6 @@ func (sq *servingQueue) queueLoop() {
sq.recentTime += expTime
sqServedGauge.Update(int64(sq.recentTime))
sqQueuedGauge.Update(int64(sq.queuedTime))
if sq.queue.Size() == 0 {
sq.best = nil
} else {
@ -341,17 +322,13 @@ func (sq *servingQueue) queueLoop() {
// of active thread controller goroutines.
func (sq *servingQueue) threadCountLoop() {
var threadCountTarget int
defer sq.wg.Done()
for {
for threadCountTarget > sq.threadCount {
sq.wg.Add(1)
go sq.threadController()
sq.threadCount++
}
if threadCountTarget < sq.threadCount {
select {
case threadCountTarget = <-sq.setThreadsCh:

20
les/state_accessor.go
View file

@ -17,7 +17,7 @@
package les
import (
"context"
contextLib "context"
"errors"
"fmt"
@ -34,12 +34,12 @@ import (
var noopReleaser = tracers.StateReleaseFunc(func() {})
// stateAtBlock retrieves the state database associated with a certain block.
func (leth *LightEthereum) stateAtBlock(ctx context.Context, block *types.Block, _ uint64) (*state.StateDB, tracers.StateReleaseFunc, error) {
func (leth *LightEthereum) stateAtBlock(ctx contextLib.Context, block *types.Block, reexec uint64) (*state.StateDB, tracers.StateReleaseFunc, error) {
return light.NewState(ctx, block.Header(), leth.odr), noopReleaser, nil
}
// stateAtTransaction returns the execution environment of a certain transaction.
func (leth *LightEthereum) stateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (*core.Message, vm.BlockContext, *state.StateDB, tracers.StateReleaseFunc, error) {
func (leth *LightEthereum) stateAtTransaction(ctx contextLib.Context, block *types.Block, txIndex int, reexec uint64) (*core.Message, vm.BlockContext, *state.StateDB, tracers.StateReleaseFunc, error) {
// Short circuit if it's genesis block.
if block.NumberU64() == 0 {
return nil, vm.BlockContext{}, nil, nil, errors.New("no transaction in genesis")
@ -49,12 +49,10 @@ func (leth *LightEthereum) stateAtTransaction(ctx context.Context, block *types.
if err != nil {
return nil, vm.BlockContext{}, nil, nil, err
}
statedb, release, err := leth.stateAtBlock(ctx, parent, reexec)
if err != nil {
return nil, vm.BlockContext{}, nil, nil, err
}
if txIndex == 0 && len(block.Transactions()) == 0 {
return nil, vm.BlockContext{}, statedb, release, nil
}
@ -64,23 +62,19 @@ func (leth *LightEthereum) stateAtTransaction(ctx context.Context, block *types.
// Assemble the transaction call message and return if the requested offset
msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee())
txContext := core.NewEVMTxContext(msg)
blockContext := core.NewEVMBlockContext(block.Header(), leth.blockchain, nil)
context := core.NewEVMBlockContext(block.Header(), leth.blockchain, nil)
statedb.SetTxContext(tx.Hash(), idx)
if idx == txIndex {
return msg, blockContext, statedb, release, nil
return msg, context, statedb, release, nil
}
// Not yet the searched for transaction, execute on top of the current state
vmenv := vm.NewEVM(blockContext, txContext, statedb, leth.blockchain.Config(), vm.Config{})
// nolint : contextcheck
if _, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(tx.Gas()), context.Background()); err != nil {
vmenv := vm.NewEVM(context, txContext, statedb, leth.blockchain.Config(), vm.Config{})
if _, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(tx.Gas()), contextLib.Background()); err != nil {
return nil, vm.BlockContext{}, nil, nil, fmt.Errorf("transaction %#x failed: %v", tx.Hash(), err)
}
// Ensure any modifications are committed to the state
// Only delete empty objects if EIP158/161 (a.k.a Spurious Dragon) is in effect
statedb.Finalise(vmenv.ChainConfig().IsEIP158(block.Number()))
}
return nil, vm.BlockContext{}, nil, nil, fmt.Errorf("transaction index %d out of range for block %#x", txIndex, block.Hash())
}

2
les/test_helper.go
View file

@ -189,7 +189,7 @@ func newTestClientHandler(backend *backends.SimulatedBackend, odr *LesOdr, index
}
)
genesis := gspec.MustCommit(db)
chain, _ := light.NewLightChain(odr, gspec.Config, engine)
chain, _ := light.NewLightChain(odr, gspec.Config, engine, nil)
client := &LightEthereum{
lesCommons: lesCommons{

11
les/txrelay.go
View file

@ -45,7 +45,6 @@ func newLesTxRelay(ps *serverPeerSet, retriever *retrieveManager) *lesTxRelay {
stop: make(chan struct{}),
}
ps.subscribe(r)
return r
}
@ -61,7 +60,6 @@ func (ltrx *lesTxRelay) registerPeer(p *serverPeer) {
if p.onlyAnnounce {
return
}
ltrx.peerList = append(ltrx.peerList, p)
}
@ -89,31 +87,25 @@ func (ltrx *lesTxRelay) send(txs types.Transactions, count int) {
for _, tx := range txs {
hash := tx.Hash()
_, ok := ltrx.txSent[hash]
if !ok {
ltrx.txSent[hash] = tx
ltrx.txPending[hash] = struct{}{}
}
if len(ltrx.peerList) > 0 {
cnt := count
pos := ltrx.peerStartPos
for {
peer := ltrx.peerList[pos]
sendTo[peer] = append(sendTo[peer], tx)
cnt--
if cnt == 0 {
break // sent it to the desired number of peers
}
pos++
if pos == len(ltrx.peerList) {
pos = 0
}
if pos == ltrx.peerStartPos {
break // tried all available peers
}
@ -142,7 +134,6 @@ func (ltrx *lesTxRelay) send(txs types.Transactions, count int) {
return func() { peer.sendTxs(reqID, len(ll), enc) }
},
}
go ltrx.retriever.retrieve(context.Background(), reqID, rq, func(p distPeer, msg *Msg) error { return nil }, ltrx.stop)
}
}
@ -169,12 +160,10 @@ func (ltrx *lesTxRelay) NewHead(head common.Hash, mined []common.Hash, rollback
if len(ltrx.txPending) > 0 {
txs := make(types.Transactions, len(ltrx.txPending))
i := 0
for hash := range ltrx.txPending {
txs[i] = ltrx.txSent[hash]
i++
}
ltrx.send(txs, 1)
}
}

8
les/utils/exec_queue.go
View file

@ -31,9 +31,7 @@ type ExecQueue struct {
func NewExecQueue(capacity int) *ExecQueue {
q := &ExecQueue{funcs: make([]func(), 0, capacity)}
q.cond = sync.NewCond(&q.mu)
go q.loop()
return q
}
@ -51,17 +49,14 @@ func (q *ExecQueue) waitNext(drop bool) (f func()) {
// dequeuing so len(q.funcs) includes the function that is running.
q.funcs = append(q.funcs[:0], q.funcs[1:]...)
}
for !q.isClosed() {
if len(q.funcs) > 0 {
f = q.funcs[0]
break
}
q.cond.Wait()
}
q.mu.Unlock()
return f
}
@ -74,21 +69,18 @@ func (q *ExecQueue) CanQueue() bool {
q.mu.Lock()
ok := !q.isClosed() && len(q.funcs) < cap(q.funcs)
q.mu.Unlock()
return ok
}
// Queue adds a function call to the execution Queue. Returns true if successful.
func (q *ExecQueue) Queue(f func()) bool {
q.mu.Lock()
ok := !q.isClosed() && len(q.funcs) < cap(q.funcs)
if ok {
q.funcs = append(q.funcs, f)
q.cond.Signal()
}
q.mu.Unlock()
return ok
}

4
les/utils/exec_queue_test.go
View file

@ -26,7 +26,6 @@ func TestExecQueue(t *testing.T) {
execd = make(chan int)
testexit = make(chan struct{})
)
defer q.Quit()
defer close(testexit)
@ -39,11 +38,9 @@ func TestExecQueue(t *testing.T) {
case <-testexit:
}
}
if q.CanQueue() != wantOK {
t.Fatalf("CanQueue() == %t for %s", !wantOK, state)
}
if q.Queue(qf) != wantOK {
t.Fatalf("Queue() == %t for %s", !wantOK, state)
}
@ -53,7 +50,6 @@ func TestExecQueue(t *testing.T) {
check("queue below cap", true)
}
check("full queue", false)
for i := 0; i < N; i++ {
if c := <-execd; c != i {
t.Fatal("execution out of order")

16
les/utils/expiredvalue.go
View file

@ -77,17 +77,14 @@ func (e ExpiredValue) Value(logOffset Fixed64) uint64 {
func (e *ExpiredValue) Add(amount int64, logOffset Fixed64) int64 {
integer, frac := logOffset.ToUint64(), logOffset.Fraction()
factor := frac.Pow2()
base := factor * float64(amount)
if integer < e.Exp {
base /= math.Pow(2, float64(e.Exp-integer))
}
if integer > e.Exp {
e.Base >>= (integer - e.Exp)
e.Exp = integer
}
if base >= 0 || uint64(-base) <= e.Base {
// The conversion from negative float64 to
// uint64 is undefined in golang, and doesn't
@ -98,13 +95,10 @@ func (e *ExpiredValue) Add(amount int64, logOffset Fixed64) int64 {
} else {
e.Base -= uint64(-base)
}
return amount
}
net := int64(-float64(e.Base) / factor)
e.Base = 0
return net
}
@ -113,12 +107,10 @@ func (e *ExpiredValue) AddExp(a ExpiredValue) {
if e.Exp > a.Exp {
a.Base >>= (e.Exp - a.Exp)
}
if e.Exp < a.Exp {
e.Base >>= (a.Exp - e.Exp)
e.Exp = a.Exp
}
e.Base += a.Base
}
@ -127,12 +119,10 @@ func (e *ExpiredValue) SubExp(a ExpiredValue) {
if e.Exp > a.Exp {
a.Base >>= (e.Exp - a.Exp)
}
if e.Exp < a.Exp {
e.Base >>= (a.Exp - e.Exp)
e.Exp = a.Exp
}
if e.Base > a.Base {
e.Base -= a.Base
} else {
@ -165,7 +155,6 @@ func (e LinearExpiredValue) Value(now mclock.AbsTime) uint64 {
e.Val = 0
}
}
return e.Val
}
@ -180,16 +169,13 @@ func (e *LinearExpiredValue) Add(amount int64, now mclock.AbsTime) uint64 {
} else {
e.Val = 0
}
e.Offset = offset
}
if amount < 0 && uint64(-amount) > e.Val {
e.Val = 0
} else {
e.Val = uint64(int64(e.Val) + amount)
}
return e.Val
}
@ -222,7 +208,6 @@ func (e *Expirer) SetRate(now mclock.AbsTime, rate float64) {
if dt > 0 {
e.logOffset += Fixed64(logToFixedFactor * float64(dt) * e.rate)
}
e.lastUpdate = now
e.rate = rate
}
@ -245,7 +230,6 @@ func (e *Expirer) LogOffset(now mclock.AbsTime) Fixed64 {
if dt <= 0 {
return e.logOffset
}
return e.logOffset + Fixed64(logToFixedFactor*float64(dt)*e.rate)
}

9
les/utils/expiredvalue_test.go
View file

@ -34,7 +34,6 @@ func TestValueExpiration(t *testing.T) {
{ExpiredValue{Base: 128, Exp: 2}, Uint64ToFixed64(2), 128},
{ExpiredValue{Base: 128, Exp: 2}, Uint64ToFixed64(3), 64},
}
for _, c := range cases {
if got := c.input.Value(c.timeOffset); got != c.expect {
t.Fatalf("Value mismatch, want=%d, got=%d", c.expect, got)
@ -70,12 +69,10 @@ func TestValueAddition(t *testing.T) {
{ExpiredValue{Base: 128, Exp: 2}, -128, Uint64ToFixed64(1), 128, -128},
{ExpiredValue{Base: 128, Exp: 2}, -128, Uint64ToFixed64(2), 0, -128},
}
for _, c := range cases {
if net := c.input.Add(c.addend, c.timeOffset); net != c.expectNet {
t.Fatalf("Net amount mismatch, want=%d, got=%d", c.expectNet, net)
}
if got := c.input.Value(c.timeOffset); got != c.expect {
t.Fatalf("Value mismatch, want=%d, got=%d", c.expect, got)
}
@ -94,10 +91,8 @@ func TestExpiredValueAddition(t *testing.T) {
{ExpiredValue{Base: 128, Exp: 0}, ExpiredValue{Base: 128, Exp: 1}, Uint64ToFixed64(0), 384},
{ExpiredValue{Base: 128, Exp: 0}, ExpiredValue{Base: 128, Exp: 0}, Uint64ToFixed64(1), 128},
}
for _, c := range cases {
c.input.AddExp(c.another)
if got := c.input.Value(c.timeOffset); got != c.expect {
t.Fatalf("Value mismatch, want=%d, got=%d", c.expect, got)
}
@ -116,10 +111,8 @@ func TestExpiredValueSubtraction(t *testing.T) {
{ExpiredValue{Base: 128, Exp: 1}, ExpiredValue{Base: 128, Exp: 0}, Uint64ToFixed64(0), 128},
{ExpiredValue{Base: 128, Exp: 1}, ExpiredValue{Base: 128, Exp: 0}, Uint64ToFixed64(1), 64},
}
for _, c := range cases {
c.input.SubExp(c.another)
if got := c.input.Value(c.timeOffset); got != c.expect {
t.Fatalf("Value mismatch, want=%d, got=%d", c.expect, got)
}
@ -156,7 +149,6 @@ func TestLinearExpiredValue(t *testing.T) {
Rate: mclock.AbsTime(1),
}, mclock.AbsTime(3), 0},
}
for _, c := range cases {
if value := c.value.Value(c.now); value != c.expect {
t.Fatalf("Value mismatch, want=%d, got=%d", c.expect, value)
@ -195,7 +187,6 @@ func TestLinearExpiredAddition(t *testing.T) {
Rate: mclock.AbsTime(1),
}, -2, mclock.AbsTime(2), 0},
}
for _, c := range cases {
if value := c.value.Add(c.amount, c.now); value != c.expect {
t.Fatalf("Value mismatch, want=%d, got=%d", c.expect, value)

57
les/utils/limiter.go
View file

@ -17,10 +17,10 @@
package utils
import (
"sort"
"sync"
"github.com/ethereum/go-ethereum/p2p/enode"
"golang.org/x/exp/slices"
)
const maxSelectionWeight = 1000000000 // maximum selection weight of each individual node/address group
@ -77,7 +77,6 @@ func (ag *addressGroup) add(nq *nodeQueue) {
if nq.groupIndex != -1 {
panic("added node queue is already in an address group")
}
l := len(ag.nodes)
nq.groupIndex = l
ag.nodes = append(ag.nodes, nq)
@ -93,7 +92,6 @@ func (ag *addressGroup) update(nq *nodeQueue, weight uint64) {
if nq.groupIndex == -1 || nq.groupIndex >= len(ag.nodes) || ag.nodes[nq.groupIndex] != nq {
panic("updated node queue is not in this address group")
}
ag.sumFlatWeight += weight - nq.flatWeight
nq.flatWeight = weight
ag.groupWeight = ag.sumFlatWeight / uint64(len(ag.nodes))
@ -112,17 +110,14 @@ func (ag *addressGroup) remove(nq *nodeQueue) {
ag.nodes[nq.groupIndex] = ag.nodes[l]
ag.nodes[nq.groupIndex].groupIndex = nq.groupIndex
}
nq.groupIndex = -1
ag.nodes = ag.nodes[:l]
ag.sumFlatWeight -= nq.flatWeight
if l >= 1 {
ag.groupWeight = ag.sumFlatWeight / uint64(l)
} else {
ag.groupWeight = 0
}
ag.nodeSelect.Remove(nq)
}
@ -141,9 +136,7 @@ func NewLimiter(sumCostLimit uint) *Limiter {
sumCostLimit: sumCostLimit,
}
l.cond = sync.NewCond(&l.lock)
go l.processLoop()
return l
}
@ -154,33 +147,25 @@ func (l *Limiter) selectionWeights(reqCost uint, value float64) (flatWeight, val
if value > l.maxValue {
l.maxValue = value
}
if value > 0 {
// normalize value to <= 1
value /= l.maxValue
}
if reqCost > l.maxCost {
l.maxCost = reqCost
}
relCost := float64(reqCost) / float64(l.maxCost)
var f float64
if relCost <= 0.001 {
f = 1
} else {
f = 0.001 / relCost
}
f *= maxSelectionWeight
flatWeight, valueWeight = uint64(f), uint64(f*value)
if flatWeight == 0 {
flatWeight = 1
}
return
}
@ -198,17 +183,14 @@ func (l *Limiter) Add(id enode.ID, address string, value float64, reqCost uint)
close(process)
return process
}
if reqCost == 0 {
reqCost = 1
}
if nq, ok := l.nodes[id]; ok {
if nq.queue != nil {
nq.queue = append(nq.queue, request{process, reqCost})
nq.sumCost += reqCost
nq.value = value
if address != nq.address {
// known id sending request from a new address, move to different address group
l.removeFromGroup(nq)
@ -219,7 +201,6 @@ func (l *Limiter) Add(id enode.ID, address string, value float64, reqCost uint)
nq.penaltyCost += reqCost
l.update(nq)
close(process)
return process
}
} else {
@ -231,24 +212,19 @@ func (l *Limiter) Add(id enode.ID, address string, value float64, reqCost uint)
groupIndex: -1,
}
nq.flatWeight, nq.valueWeight = l.selectionWeights(reqCost, value)
if len(l.nodes) == 0 {
l.cond.Signal()
}
l.nodes[id] = nq
if nq.valueWeight != 0 {
l.valueSelect.Update(nq)
}
l.addToGroup(nq, address)
}
l.sumCost += reqCost
if l.sumCost > l.sumCostLimit {
l.dropRequests()
}
return process
}
@ -260,12 +236,10 @@ func (l *Limiter) update(nq *nodeQueue) {
} else {
cost = nq.penaltyCost
}
flatWeight, valueWeight := l.selectionWeights(cost, nq.value)
ag := l.addresses[nq.address]
ag.update(nq, flatWeight)
l.addressSelect.Update(ag)
nq.valueWeight = valueWeight
l.valueSelect.Update(nq)
}
@ -274,13 +248,11 @@ func (l *Limiter) update(nq *nodeQueue) {
// it does not exist yet.
func (l *Limiter) addToGroup(nq *nodeQueue, address string) {
nq.address = address
ag := l.addresses[address]
if ag == nil {
ag = &addressGroup{nodeSelect: NewWeightedRandomSelect(flatWeight)}
l.addresses[address] = ag
}
ag.add(nq)
l.addressSelect.Update(ag)
}
@ -289,11 +261,9 @@ func (l *Limiter) addToGroup(nq *nodeQueue, address string) {
func (l *Limiter) removeFromGroup(nq *nodeQueue) {
ag := l.addresses[nq.address]
ag.remove(nq)
if len(ag.nodes) == 0 {
delete(l.addresses, nq.address)
}
l.addressSelect.Update(ag)
}
@ -301,11 +271,9 @@ func (l *Limiter) removeFromGroup(nq *nodeQueue) {
// selector
func (l *Limiter) remove(nq *nodeQueue) {
l.removeFromGroup(nq)
if nq.valueWeight != 0 {
l.valueSelect.Remove(nq)
}
delete(l.nodes, nq.id)
}
@ -317,10 +285,8 @@ func (l *Limiter) choose() *nodeQueue {
return ag.choose()
}
}
nq, _ := l.valueSelect.Choose().(*nodeQueue)
l.selectAddressNext = true
return nq
}
@ -336,23 +302,19 @@ func (l *Limiter) processLoop() {
close(request.process)
}
}
return
}
nq := l.choose()
if nq == nil {
l.cond.Wait()
continue
}
if nq.queue != nil {
request := nq.queue[0]
nq.queue = nq.queue[1:]
nq.sumCost -= request.cost
l.sumCost -= request.cost
l.lock.Unlock()
ch := make(chan struct{})
request.process <- ch
<-ch
@ -391,29 +353,31 @@ func (l *Limiter) dropRequests() {
sumValue float64
list []dropListItem
)
for _, nq := range l.nodes {
sumValue += nq.value
}
for _, nq := range l.nodes {
if nq.sumCost == 0 {
continue
}
w := 1 / float64(len(l.addresses)*len(l.addresses[nq.address].nodes))
if sumValue > 0 {
w += nq.value / sumValue
}
list = append(list, dropListItem{
nq: nq,
priority: w / float64(nq.sumCost),
})
}
sort.Sort(list)
slices.SortFunc(list, func(a, b dropListItem) int {
if a.priority < b.priority {
return -1
}
if a.priority < b.priority {
return 1
}
return 0
})
for _, item := range list {
for _, request := range item.nq.queue {
close(request.process)
@ -427,7 +391,6 @@ func (l *Limiter) dropRequests() {
l.sumCost -= item.nq.sumCost // penalty costs are not counted in sumCost
item.nq.sumCost = 0
l.update(item.nq)
if l.sumCost <= l.sumCostLimit/2 {
return
}

22
les/utils/limiter_test.go
View file

@ -58,26 +58,21 @@ func (lt *limTest) request(n *ltNode) {
address string
id enode.ID
)
if n.addr >= 0 {
address = string([]byte{byte(n.addr)})
} else {
var b [32]byte
rand.Read(b[:])
address = string(b[:])
}
if n.id >= 0 {
id = enode.ID{byte(n.id)}
} else {
rand.Read(id[:])
}
lt.runCount++
n.runCount++
cch := lt.limiter.Add(id, address, n.value, n.cost)
go func() {
lt.results <- ltResult{n, <-cch}
}()
@ -88,10 +83,8 @@ func (lt *limTest) moreRequests(n *ltNode) {
if maxStart != 0 {
n.lastTotalCost = lt.totalCost
}
for n.reqMax > n.runCount && maxStart > 0 {
lt.request(n)
maxStart--
}
}
@ -99,14 +92,12 @@ func (lt *limTest) moreRequests(n *ltNode) {
func (lt *limTest) process() {
res := <-lt.results
lt.runCount--
res.node.runCount--
if res.ch != nil {
res.node.served++
if res.node.exp != 0 {
lt.expCost += res.node.cost
}
lt.totalCost += res.node.cost
close(res.ch)
} else {
@ -169,53 +160,41 @@ func TestLimiter(t *testing.T) {
for _, test := range limTests {
lt.expCost, lt.totalCost = 0, 0
iterCount := 10000
for j := 0; j < ltRounds; j++ {
// try to reach expected target range in multiple rounds with increasing iteration counts
last := j == ltRounds-1
for _, n := range test {
lt.request(n)
}
for i := 0; i < iterCount; i++ {
lt.process()
for _, n := range test {
lt.moreRequests(n)
}
}
for lt.runCount > 0 {
lt.process()
}
if spamRatio := 1 - float64(lt.expCost)/float64(lt.totalCost); spamRatio > 0.5*(1+ltTolerance) {
t.Errorf("Spam ratio too high (%f)", spamRatio)
}
fail, success := false, true
for _, n := range test {
if n.exp != 0 {
if n.dropped > 0 {
t.Errorf("Dropped %d requests of non-spam node", n.dropped)
fail = true
}
r := float64(n.served) * float64(n.cost) / float64(lt.expCost)
if r < n.exp*(1-ltTolerance) || r > n.exp*(1+ltTolerance) {
if last {
// print error only if the target is still not reached in the last round
t.Errorf("Request ratio (%f) does not match expected value (%f)", r, n.exp)
}
success = false
}
}
}
if fail || success {
break
}
@ -223,6 +202,5 @@ func TestLimiter(t *testing.T) {
iterCount *= 2
}
}
lt.limiter.Stop()
}

4
les/utils/timeutils.go
View file

@ -39,7 +39,6 @@ func NewUpdateTimer(clock mclock.Clock, threshold time.Duration) *UpdateTimer {
if clock == nil {
clock = mclock.System{}
}
return &UpdateTimer{
clock: clock,
last: clock.Now(),
@ -59,15 +58,12 @@ func (t *UpdateTimer) UpdateAt(at mclock.AbsTime, callback func(diff time.Durati
if diff < 0 {
diff = 0
}
if diff < t.threshold {
return false
}
if callback(diff) {
t.last = at
return true
}
return false
}

6
les/utils/timeutils_test.go
View file

@ -28,24 +28,18 @@ func TestUpdateTimer(t *testing.T) {
if timer != nil {
t.Fatalf("Create update timer with negative threshold")
}
sim := &mclock.Simulated{}
timer = NewUpdateTimer(sim, time.Second)
if updated := timer.Update(func(diff time.Duration) bool { return true }); updated {
t.Fatalf("Update the clock without reaching the threshold")
}
sim.Run(time.Second)
if updated := timer.Update(func(diff time.Duration) bool { return true }); !updated {
t.Fatalf("Doesn't update the clock when reaching the threshold")
}
if updated := timer.UpdateAt(sim.Now().Add(time.Second), func(diff time.Duration) bool { return true }); !updated {
t.Fatalf("Doesn't update the clock when reaching the threshold")
}
timer = NewUpdateTimer(sim, 0)
if updated := timer.Update(func(diff time.Duration) bool { return true }); !updated {
t.Fatalf("Doesn't update the clock without threshold limitaion")

20
les/utils/weighted_select.go
View file

@ -60,17 +60,14 @@ func (w *WeightedRandomSelect) setWeight(item WrsItem, weight uint64) {
if weight > math.MaxInt64-w.root.sumCost {
// old weight is still included in sumCost, remove and check again
w.setWeight(item, 0)
if weight > math.MaxInt64-w.root.sumCost {
log.Error("WeightedRandomSelect overflow", "sumCost", w.root.sumCost, "new weight", weight)
weight = math.MaxInt64 - w.root.sumCost
}
}
idx, ok := w.idx[item]
if ok {
w.root.setWeight(idx, weight)
if weight == 0 {
delete(w.idx, item)
}
@ -83,7 +80,6 @@ func (w *WeightedRandomSelect) setWeight(item WrsItem, weight uint64) {
newRoot.weights[0] = w.root.sumCost
w.root = newRoot
}
w.idx[item] = w.root.insert(item, weight)
}
}
@ -98,15 +94,12 @@ func (w *WeightedRandomSelect) Choose() WrsItem {
if w.root.sumCost == 0 {
return nil
}
val := uint64(rand.Int63n(int64(w.root.sumCost)))
choice, lastWeight := w.root.choose(val)
weight := w.wfn(choice)
if weight != lastWeight {
w.setWeight(choice, weight)
}
if weight >= lastWeight || uint64(rand.Int63n(int64(lastWeight))) < weight {
return choice
}
@ -132,16 +125,13 @@ func (n *wrsNode) insert(item WrsItem, weight uint64) int {
panic(nil)
}
}
n.itemCnt++
n.sumCost += weight
n.weights[branch] += weight
if n.level == 0 {
n.items[branch] = item
return branch
}
var subNode *wrsNode
if n.items[branch] == nil {
subNode = &wrsNode{maxItems: n.maxItems / wrsBranches, level: n.level - 1}
@ -149,9 +139,7 @@ func (n *wrsNode) insert(item WrsItem, weight uint64) int {
} else {
subNode = n.items[branch].(*wrsNode)
}
subIdx := subNode.insert(item, weight)
return subNode.maxItems*branch + subIdx
}
@ -162,26 +150,21 @@ func (n *wrsNode) setWeight(idx int, weight uint64) uint64 {
oldWeight := n.weights[idx]
n.weights[idx] = weight
diff := weight - oldWeight
n.sumCost += diff
if weight == 0 {
n.items[idx] = nil
n.itemCnt--
}
return diff
}
branchItems := n.maxItems / wrsBranches
branch := idx / branchItems
diff := n.items[branch].(*wrsNode).setWeight(idx-branch*branchItems, weight)
n.weights[branch] += diff
n.sumCost += diff
if weight == 0 {
n.itemCnt--
}
return diff
}
@ -192,12 +175,9 @@ func (n *wrsNode) choose(val uint64) (WrsItem, uint64) {
if n.level == 0 {
return n.items[i].(WrsItem), n.weights[i]
}
return n.items[i].(*wrsNode).choose(val)
}
val -= w
}
panic(nil)
}

7
les/utils/weighted_select_test.go
View file

@ -29,11 +29,9 @@ type testWrsItem struct {
func testWeight(i interface{}) uint64 {
t := i.(*testWrsItem)
w := *t.widx
if w == -1 || w == t.idx {
return uint64(t.idx + 1)
}
return 0
}
@ -42,14 +40,11 @@ func TestWeightedRandomSelect(t *testing.T) {
s := NewWeightedRandomSelect(testWeight)
w := -1
list := make([]testWrsItem, cnt)
for i := range list {
list[i] = testWrsItem{idx: i, widx: &w}
s.Update(&list[i])
}
w = rand.Intn(cnt)
c := s.Choose()
if c == nil {
t.Errorf("expected item, got nil")
@ -58,9 +53,7 @@ func TestWeightedRandomSelect(t *testing.T) {
t.Errorf("expected another item")
}
}
w = -2
if s.Choose() != nil {
t.Errorf("expected nil, got item")
}

6
les/vflux/client/api.go
View file

@ -39,7 +39,6 @@ func parseNodeStr(nodeStr string) (enode.ID, error) {
if id, err := enode.ParseID(nodeStr); err == nil {
return id, nil
}
if node, err := enode.Parse(enode.ValidSchemes, nodeStr); err == nil {
return node.ID(), nil
} else {
@ -64,11 +63,9 @@ func (api *PrivateClientAPI) Distribution(nodeStr string, normalized bool) (RtDi
if !normalized {
expFactor = utils.ExpFactor(api.vt.StatsExpirer().LogOffset(mclock.Now()))
}
if nodeStr == "" {
return api.vt.RtStats().Distribution(normalized, expFactor), nil
}
if id, err := parseNodeStr(nodeStr); err == nil {
return api.vt.GetNode(id).RtStats().Distribution(normalized, expFactor), nil
} else {
@ -87,7 +84,6 @@ func (api *PrivateClientAPI) Timeout(nodeStr string, failRate float64) (float64,
if nodeStr == "" {
return float64(api.vt.RtStats().Timeout(failRate)) / float64(time.Second), nil
}
if id, err := parseNodeStr(nodeStr); err == nil {
return float64(api.vt.GetNode(id).RtStats().Timeout(failRate)) / float64(time.Second), nil
} else {
@ -100,11 +96,9 @@ func (api *PrivateClientAPI) Timeout(nodeStr string, failRate float64) (float64,
func (api *PrivateClientAPI) Value(nodeStr string, timeout float64) (float64, error) {
wt := TimeoutWeights(time.Duration(timeout * float64(time.Second)))
expFactor := utils.ExpFactor(api.vt.StatsExpirer().LogOffset(mclock.Now()))
if nodeStr == "" {
return api.vt.RtStats().Value(wt, expFactor), nil
}
if id, err := parseNodeStr(nodeStr); err == nil {
return api.vt.GetNode(id).RtStats().Value(wt, expFactor), nil
} else {

5
les/vflux/client/fillset.go
View file

@ -52,11 +52,9 @@ func NewFillSet(ns *nodestate.NodeStateMachine, input enode.Iterator, flags node
if oldState.Equals(flags) {
fs.count--
}
if newState.Equals(flags) {
fs.count++
}
if fs.target > fs.count {
fs.cond.Signal()
}
@ -64,7 +62,6 @@ func NewFillSet(ns *nodestate.NodeStateMachine, input enode.Iterator, flags node
})
go fs.readLoop()
return fs
}
@ -78,11 +75,9 @@ func (fs *FillSet) readLoop() {
}
fs.lock.Unlock()
if !fs.input.Next() {
return
}
fs.ns.SetState(fs.input.Node(), fs.flags, nodestate.Flags{}, 0)
}
}

4
les/vflux/client/fillset_test.go
View file

@ -37,9 +37,7 @@ func (i *testIter) Next() bool {
if _, ok := <-i.waitCh; !ok {
return false
}
i.node = <-i.nodeCh
return true
}
@ -53,7 +51,6 @@ func (i *testIter) Close() {
func (i *testIter) push() {
var id enode.ID
rand.Read(id[:])
i.nodeCh <- enode.SignNull(new(enr.Record), id)
}
@ -81,7 +78,6 @@ func TestFillSet(t *testing.T) {
if !iter.waiting(time.Second * 10) {
t.Fatalf("FillSet not waiting for new nodes")
}
if push {
iter.push()
}

9
les/vflux/client/queueiterator.go
View file

@ -50,7 +50,6 @@ func NewQueueIterator(ns *nodestate.NodeStateMachine, requireFlags, disableFlags
ns.SubscribeState(requireFlags.Or(disableFlags), func(n *enode.Node, oldState, newState nodestate.Flags) {
oldMatch := oldState.HasAll(requireFlags) && oldState.HasNone(disableFlags)
newMatch := newState.HasAll(requireFlags) && newState.HasNone(disableFlags)
if newMatch == oldMatch {
return
}
@ -66,15 +65,12 @@ func NewQueueIterator(ns *nodestate.NodeStateMachine, requireFlags, disableFlags
if qn.ID() == id {
copy(qi.queue[i:len(qi.queue)-1], qi.queue[i+1:])
qi.queue = qi.queue[:len(qi.queue)-1]
break
}
}
}
qi.cond.Signal()
})
return qi
}
@ -85,20 +81,16 @@ func (qi *QueueIterator) Next() bool {
if qi.waitCallback != nil {
qi.waitCallback(true)
}
for !qi.closed && len(qi.queue) == 0 {
qi.cond.Wait()
}
if qi.waitCallback != nil {
qi.waitCallback(false)
}
}
if qi.closed {
qi.nextNode = nil
qi.lock.Unlock()
return false
}
// Move to the next node in queue.
@ -111,7 +103,6 @@ func (qi *QueueIterator) Next() bool {
qi.queue = qi.queue[:len(qi.queue)-1]
}
qi.lock.Unlock()
return true
}

4
les/vflux/client/queueiterator_test.go
View file

@ -42,11 +42,9 @@ func testQueueIterator(t *testing.T, fifo bool) {
ns := nodestate.NewNodeStateMachine(nil, nil, &mclock.Simulated{}, testSetup)
qi := NewQueueIterator(ns, sfTest2, sfTest3.Or(sfTest4), fifo, nil)
ns.Start()
for i := 1; i <= iterTestNodeCount; i++ {
ns.SetState(testNode(i), sfTest1, nodestate.Flags{}, 0)
}
next := func() int {
ch := make(chan struct{})
go func() {
@ -58,10 +56,8 @@ func testQueueIterator(t *testing.T, fifo bool) {
case <-time.After(time.Second * 5):
t.Fatalf("Iterator.Next() timeout")
}
node := qi.Node()
ns.SetState(node, sfTest4, nodestate.Flags{}, 0)
return testNodeIndex(node.ID())
}
exp := func(i int) {

28
les/vflux/client/requestbasket.go
View file

@ -80,10 +80,8 @@ func (b *requestBasket) setExp(exp uint64) {
item.value >>= shift
b.items[i] = item
}
b.exp = exp
}
if exp < b.exp {
shift := b.exp - exp
for i, item := range b.items {
@ -91,7 +89,6 @@ func (b *requestBasket) setExp(exp uint64) {
item.value <<= shift
b.items[i] = item
}
b.exp = exp
}
}
@ -127,23 +124,18 @@ func (s *serverBasket) transfer(ratio float64) requestBasket {
items: make([]basketItem, len(s.basket.items)),
exp: s.basket.exp,
}
for i, v := range s.basket.items {
ta := uint64(float64(v.amount) * ratio)
tv := uint64(float64(v.value) * ratio)
if ta > v.amount {
ta = v.amount
}
if tv > v.value {
tv = v.value
}
s.basket.items[i] = basketItem{v.amount - ta, v.value - tv}
res.items[i] = basketItem{ta, tv}
}
return res
}
@ -165,22 +157,18 @@ func (r *referenceBasket) add(newBasket requestBasket) {
totalCost uint64
totalValue float64
)
for i, v := range newBasket.items {
totalCost += v.value
totalValue += float64(v.amount) * r.reqValues[i]
}
if totalCost > 0 {
// add to reference with scaled values
scaleValues := totalValue / float64(totalCost)
for i, v := range newBasket.items {
r.basket.items[i].amount += v.amount
r.basket.items[i].value += uint64(float64(v.value) * scaleValues)
}
}
r.updateReqValues()
}
@ -204,7 +192,6 @@ func (r *referenceBasket) normalize() {
sumAmount += b.amount
sumValue += b.value
}
add := float64(int64(sumAmount-sumValue)) / float64(sumValue)
for i, b := range r.basket.items {
b.value += uint64(int64(float64(b.value) * add))
@ -219,16 +206,13 @@ func (r *referenceBasket) reqValueFactor(costList []uint64) float64 {
totalCost float64
totalValue uint64
)
for i, b := range r.basket.items {
totalCost += float64(costList[i]) * float64(b.amount) // use floats to avoid overflow
totalValue += b.value
}
if totalCost < 1 {
return 0
}
return float64(totalValue) * basketFactor / totalCost
}
@ -242,13 +226,10 @@ func (b *basketItem) DecodeRLP(s *rlp.Stream) error {
var item struct {
Amount, Value uint64
}
if err := s.Decode(&item); err != nil {
return err
}
b.amount, b.value = item.Amount, item.Value
return nil
}
@ -263,13 +244,10 @@ func (r *requestBasket) DecodeRLP(s *rlp.Stream) error {
Items []basketItem
Exp uint64
}
if err := s.Decode(&enc); err != nil {
return err
}
r.items, r.exp = enc.Items, enc.Exp
return nil
}
@ -283,11 +261,8 @@ func (r requestBasket) convertMapping(oldMapping, newMapping []string, initBaske
for i, name := range oldMapping {
nameMap[name] = i
}
rc := requestBasket{items: make([]basketItem, len(newMapping))}
var scale, oldScale, newScale float64
for i, name := range newMapping {
if ii, ok := nameMap[name]; ok {
rc.items[i] = r.items[ii]
@ -295,19 +270,16 @@ func (r requestBasket) convertMapping(oldMapping, newMapping []string, initBaske
newScale += float64(rc.items[i].amount) * float64(initBasket.items[i].amount)
}
}
if oldScale > 1e-10 {
scale = newScale / oldScale
} else {
scale = 1
}
for i, name := range newMapping {
if _, ok := nameMap[name]; !ok {
rc.items[i].amount = uint64(float64(initBasket.items[i].amount) * scale)
rc.items[i].value = uint64(float64(initBasket.items[i].value) * scale)
}
}
return rc
}

14
les/vflux/client/requestbasket_test.go
View file

@ -37,11 +37,9 @@ func checkF64(t *testing.T, name string, value, exp, tol float64) {
func TestServerBasket(t *testing.T) {
var s serverBasket
s.init(2)
// add some requests with different request value factors
s.updateRvFactor(1)
noexp := utils.ExpirationFactor{Factor: 1}
s.add(0, 1000, 10000, noexp)
s.add(1, 3000, 60000, noexp)
@ -85,13 +83,11 @@ func TestConvertMapping(t *testing.T) {
func TestReqValueFactor(t *testing.T) {
var ref referenceBasket
ref.basket = requestBasket{items: make([]basketItem, 4)}
for i := range ref.basket.items {
ref.basket.items[i].amount = uint64(i+1) * basketFactor
ref.basket.items[i].value = uint64(i+1) * basketFactor
}
ref.init(4)
rvf := ref.reqValueFactor([]uint64{1000, 2000, 3000, 4000})
// expected value is (1000000+2000000+3000000+4000000) / (1*1000+2*2000+3*3000+4*4000) = 10000000/30000 = 333.333
@ -103,7 +99,6 @@ func TestNormalize(t *testing.T) {
// Initialize data for testing
valueRange, lower := 1000000, 1000000
ref := referenceBasket{basket: requestBasket{items: make([]basketItem, 10)}}
for i := 0; i < 10; i++ {
ref.basket.items[i].amount = uint64(rand.Intn(valueRange) + lower)
ref.basket.items[i].value = uint64(rand.Intn(valueRange) + lower)
@ -116,7 +111,6 @@ func TestNormalize(t *testing.T) {
sumAmount += ref.basket.items[i].amount
sumValue += ref.basket.items[i].value
}
var epsilon = 0.01
if float64(sumAmount)*(1+epsilon) < float64(sumValue) || float64(sumAmount)*(1-epsilon) > float64(sumValue) {
t.Fatalf("Failed to normalize sumAmount: %d sumValue: %d", sumAmount, sumValue)
@ -126,31 +120,24 @@ func TestNormalize(t *testing.T) {
func TestReqValueAdjustment(t *testing.T) {
var s1, s2 serverBasket
s1.init(3)
s2.init(3)
cost1 := []uint64{30000, 60000, 90000}
cost2 := []uint64{100000, 200000, 300000}
var ref referenceBasket
ref.basket = requestBasket{items: make([]basketItem, 3)}
for i := range ref.basket.items {
ref.basket.items[i].amount = 123 * basketFactor
ref.basket.items[i].value = 123 * basketFactor
}
ref.init(3)
// initial reqValues are expected to be {1, 1, 1}
checkF64(t, "reqValues[0]", ref.reqValues[0], 1, 0.01)
checkF64(t, "reqValues[1]", ref.reqValues[1], 1, 0.01)
checkF64(t, "reqValues[2]", ref.reqValues[2], 1, 0.01)
var logOffset utils.Fixed64
for period := 0; period < 1000; period++ {
exp := utils.ExpFactor(logOffset)
s1.updateRvFactor(ref.reqValueFactor(cost1))
s2.updateRvFactor(ref.reqValueFactor(cost2))
// throw in random requests into each basket using their internal pricing
@ -166,7 +153,6 @@ func TestReqValueAdjustment(t *testing.T) {
ref.add(s2.transfer(0.1))
ref.normalize()
ref.updateReqValues()
logOffset += utils.Float64ToFixed64(0.1)
}
checkF64(t, "reqValues[0]", ref.reqValues[0], 0.5, 0.01)

Some files were not shown because too many files have changed in this diff Show more