PoS_EVM
/
woop
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[rpc] more update in rpc

Browse Source
pull/3845/head
Jacky Wang 3 years ago committed by Leo Chen
parent 132ea783b6
commit ecd3b950d4
4 changed files with 187 additions and 150 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 4
      core/blockchain.go
  2. 289
      rpc/blockchain.go
  3. 2
      rpc/staking.go
  4. 2
      rpc/transaction.go

4
core/blockchain.go
Unescape View File

@ -69,8 +69,8 @@ var (
)
const (
bodyCacheLimit = 256
blockCacheLimit = 256
bodyCacheLimit = 2048
blockCacheLimit = 2048
receiptsCacheLimit = 32
maxFutureBlocks = 256
maxTimeFutureBlocks = 30

289
rpc/blockchain.go
Unescape View File

@ -4,13 +4,18 @@ import (
"context"
"fmt"
"math/big"
"strconv"
"time"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/rpc"
lru "github.com/hashicorp/golang-lru"
"github.com/pkg/errors"
"github.com/prometheus/client_golang/prometheus"
"golang.org/x/time/rate"
"github.com/harmony-one/harmony/core/types"
internal_bls "github.com/harmony-one/harmony/crypto/bls"
"github.com/harmony-one/harmony/hmy"
"github.com/harmony-one/harmony/internal/chain"
internal_common "github.com/harmony-one/harmony/internal/common"
@ -23,10 +28,6 @@ import (
v2 "github.com/harmony-one/harmony/rpc/v2"
"github.com/harmony-one/harmony/shard"
stakingReward "github.com/harmony-one/harmony/staking/reward"
lru "github.com/hashicorp/golang-lru"
"github.com/pkg/errors"
"github.com/prometheus/client_golang/prometheus"
"golang.org/x/time/rate"
)
// PublicBlockchainService provides an API to access the Harmony blockchain.
@ -36,6 +37,7 @@ type PublicBlockchainService struct {
version Version
limiter *rate.Limiter
rpcBlockFactory rpc_common.BlockFactory
helper *bcServiceHelper
}
const (
@ -59,14 +61,15 @@ func NewPublicBlockchainAPI(hmy *hmy.Harmony, version Version, limiterEnable boo
version: version,
limiter: limiter,
}
s.helper = s.newHelper()
switch version {
case V1:
s.rpcBlockFactory = v1.NewBlockFactory(s.helper())
s.rpcBlockFactory = v1.NewBlockFactory(s.helper)
case V2:
s.rpcBlockFactory = v2.NewBlockFactory(s.helper())
s.rpcBlockFactory = v2.NewBlockFactory(s.helper)
case Eth:
s.rpcBlockFactory = eth.NewBlockFactory(s.helper())
s.rpcBlockFactory = eth.NewBlockFactory(s.helper)
default:
// This shall not happen for legitimate code.
}
@ -103,30 +106,6 @@ func (s *PublicBlockchainService) Accounts() []common.Address {
return []common.Address{}
}
// getBlockOptions is a helper to get block args given an interface option from RPC params.
func (s *PublicBlockchainService) getBlockOptions(opts interface{}) (*rpc_common.BlockArgs, error) {
switch s.version {
case V1, Eth:
fullTx, ok := opts.(bool)
if !ok {
return nil, fmt.Errorf("invalid type for block arguments")
}
return &rpc_common.BlockArgs{
WithSigners: false,
FullTx: fullTx,
InclStaking: true,
}, nil
case V2:
parsedBlockArgs := rpc_common.BlockArgs{}
if err := parsedBlockArgs.UnmarshalFromInterface(opts); err != nil {
return nil, err
}
return &parsedBlockArgs, nil
default:
return nil, ErrUnknownRPCVersion
}
}
// getBalanceByBlockNumber returns balance by block number at given eth blockNum without checks
func (s *PublicBlockchainService) getBalanceByBlockNumber(
ctx context.Context, address string, blockNum rpc.BlockNumber,
@ -193,15 +172,11 @@ func (s *PublicBlockchainService) GetBlockByNumber(
}
// Process arguments based on version
var blockArgs *rpc_common.BlockArgs
blockArgs, ok := opts.(*rpc_common.BlockArgs)
if !ok {
blockArgs, err = s.getBlockOptions(opts)
blockArgs, err := s.getBlockOptions(opts)
if err != nil {
DoMetricRPCQueryInfo(GetBlockByNumber, FailedNumber)
return nil, err
}
}
if blockNumber.EthBlockNumber() == rpc.PendingBlockNumber {
return nil, errors.New("pending block number not implemented")
@ -214,16 +189,16 @@ func (s *PublicBlockchainService) GetBlockByNumber(
}
blk := s.hmy.BlockChain.GetBlockByNumber(blockNum)
if blk == nil {
// Some Ethereum tools (such as Truffle) rely on being able to query for future blocks without the chain returning errors.
// These tools implement retry mechanisms that will query & retry for a given block until it has been finalized.
// Throwing an error like "requested block number greater than current block number" breaks this retry functionality.
// Disable isBlockGreaterThanLatest checks for Ethereum RPC:s, but keep them in place for legacy hmy_ RPC:s for now to ensure backwards compatibility
if blk == nil {
DoMetricRPCQueryInfo(GetBlockByNumber, FailedNumber)
if s.version == Eth {
return nil, ErrRequestedBlockTooHigh
return nil, nil
}
return nil, errors.New("block unknown")
return nil, ErrRequestedBlockTooHigh
}
// Format the response according to version
rpcBlock, err := s.rpcBlockFactory.NewBlock(blk, blockArgs)
@ -250,15 +225,11 @@ func (s *PublicBlockchainService) GetBlockByHash(
}
// Process arguments based on version
var blockArgs *rpc_common.BlockArgs
blockArgs, ok := opts.(*rpc_common.BlockArgs)
if !ok {
blockArgs, err = s.getBlockOptions(opts)
blockArgs, err := s.getBlockOptions(opts)
if err != nil {
DoMetricRPCQueryInfo(GetBlockByHash, FailedNumber)
return nil, err
}
}
// Fetch the block
blk, err := s.hmy.GetBlock(ctx, blockHash)
@ -339,6 +310,7 @@ func (s *PublicBlockchainService) GetBlocks(
if err != nil {
DoMetricRPCQueryInfo(GetBlockByNumber, FailedNumber)
utils.Logger().Warn().Err(err).Msg("RPC Get Blocks Error")
return nil, err
}
if rpcBlock != nil {
result = append(result, rpcBlock)
@ -369,7 +341,9 @@ func (s *PublicBlockchainService) GetBlockSigners(
) ([]string, error) {
// Process arguments based on version
blockNum := blockNumber.EthBlockNumber()
if blockNum == rpc.PendingBlockNumber {
return nil, errors.New("cannot get signer keys for pending blocks")
}
// Ensure correct block
if blockNum.Int64() == 0 || blockNum.Int64() >= s.hmy.CurrentBlock().Number().Int64() {
return []string{}, nil
@ -377,25 +351,18 @@ func (s *PublicBlockchainService) GetBlockSigners(
if isBlockGreaterThanLatest(s.hmy, blockNum) {
return nil, ErrRequestedBlockTooHigh
}
// Fetch signers
slots, mask, err := s.hmy.GetBlockSigners(ctx, blockNum)
if err != nil {
return nil, err
}
// Response output is the same for all versions
signers := []string{}
for _, validator := range slots {
oneAddress, err := internal_common.AddressToBech32(validator.EcdsaAddress)
if err != nil {
return nil, err
}
if ok, err := mask.KeyEnabled(validator.BLSPublicKey); err == nil && ok {
signers = append(signers, oneAddress)
var bn uint64
if blockNum == rpc.LatestBlockNumber {
bn = s.hmy.CurrentBlock().NumberU64()
} else {
bn = uint64(blockNum.Int64())
}
blk := s.hmy.BlockChain.GetBlockByNumber(bn)
if blk == nil {
return nil, errors.New("unknown block")
}
return signers, nil
// Fetch signers
return s.helper.GetSigners(blk)
}
// GetBlockSignerKeys returns bls public keys that signed the block.
@ -404,7 +371,9 @@ func (s *PublicBlockchainService) GetBlockSignerKeys(
) ([]string, error) {
// Process arguments based on version
blockNum := blockNumber.EthBlockNumber()
if blockNum == rpc.PendingBlockNumber {
return nil, errors.New("cannot get signer keys for pending blocks")
}
// Ensure correct block
if blockNum.Int64() == 0 || blockNum.Int64() >= s.hmy.CurrentBlock().Number().Int64() {
return []string{}, nil
@ -412,21 +381,14 @@ func (s *PublicBlockchainService) GetBlockSignerKeys(
if isBlockGreaterThanLatest(s.hmy, blockNum) {
return nil, ErrRequestedBlockTooHigh
}
// Fetch signers
slots, mask, err := s.hmy.GetBlockSigners(ctx, blockNum)
if err != nil {
return nil, err
}
// Response output is the same for all versions
signers := []string{}
for _, validator := range slots {
if ok, err := mask.KeyEnabled(validator.BLSPublicKey); err == nil && ok {
signers = append(signers, validator.BLSPublicKey.Hex())
}
var bn uint64
if blockNum == rpc.LatestBlockNumber {
bn = s.hmy.CurrentBlock().NumberU64()
} else {
bn = uint64(blockNum.Int64())
}
return signers, nil
// Fetch signers
return s.helper.GetBLSSigners(bn)
}
// IsBlockSigner returns true if validator with address signed blockNum block.
@ -443,27 +405,17 @@ func (s *PublicBlockchainService) IsBlockSigner(
if isBlockGreaterThanLatest(s.hmy, blockNum) {
return false, ErrRequestedBlockTooHigh
}
// Fetch signers
slots, mask, err := s.hmy.GetBlockSigners(ctx, blockNum)
if err != nil {
return false, err
var bn uint64
if blockNum == rpc.PendingBlockNumber {
return false, errors.New("no signing data for pending block number")
} else if blockNum == rpc.LatestBlockNumber {
bn = s.hmy.BlockChain.CurrentBlock().NumberU64()
} else {
bn = uint64(blockNum.Int64())
}
// Check if given address is in slots (response output is the same for all versions)
for _, validator := range slots {
oneAddress, err := internal_common.AddressToBech32(validator.EcdsaAddress)
if err != nil {
return false, err
}
if oneAddress != address {
continue
}
if ok, err := mask.KeyEnabled(validator.BLSPublicKey); err == nil && ok {
return true, nil
}
}
return false, nil
// Fetch signers
return s.helper.IsSigner(address, bn)
}
// GetSignedBlocks returns how many blocks a particular validator signed for
@ -472,6 +424,10 @@ func (s *PublicBlockchainService) GetSignedBlocks(
ctx context.Context, address string,
) (interface{}, error) {
// Fetch the number of signed blocks within default period
curEpoch := s.hmy.CurrentBlock().Epoch()
var totalSigned uint64
if !s.hmy.ChainConfig().IsStaking(curEpoch) {
// calculate signed before staking epoch
totalSigned := uint64(0)
lastBlock := uint64(0)
blockHeight := s.hmy.CurrentBlock().Number().Uint64()
@ -485,6 +441,25 @@ func (s *PublicBlockchainService) GetSignedBlocks(
totalSigned++
}
}
} else {
ethAddr, err := internal_common.Bech32ToAddress(address)
if err != nil {
return nil, err
}
curVal, err := s.hmy.BlockChain.ReadValidatorInformation(ethAddr)
if err != nil {
return nil, err
}
prevVal, err := s.hmy.BlockChain.ReadValidatorSnapshot(ethAddr)
if err != nil {
return nil, err
}
signedInEpoch := new(big.Int).Sub(curVal.Counters.NumBlocksSigned, prevVal.Validator.Counters.NumBlocksSigned)
if signedInEpoch.Cmp(common.Big0) < 0 {
return nil, errors.New("negative signed in epoch")
}
totalSigned = signedInEpoch.Uint64()
}
// Format the response according to the version
switch s.version {
@ -520,13 +495,9 @@ func (s *PublicBlockchainService) GetEpoch(ctx context.Context) (interface{}, er
// GetLeader returns current shard leader.
func (s *PublicBlockchainService) GetLeader(ctx context.Context) (string, error) {
// Fetch Header
header, err := s.hmy.HeaderByNumber(ctx, rpc.LatestBlockNumber)
if err != nil {
return "", err
}
blk := s.hmy.BlockChain.CurrentBlock()
// Response output is the same for all versions
leader := s.hmy.GetLeaderAddress(header.Coinbase(), header.Epoch())
leader := s.helper.GetLeader(blk)
return leader, nil
}
@ -858,6 +829,34 @@ func (s *PublicBlockchainService) BeaconInSync(ctx context.Context) (bool, error
return inSync, nil
}
// getBlockOptions block args given an interface option from RPC params.
func (s *PublicBlockchainService) getBlockOptions(opts interface{}) (*rpc_common.BlockArgs, error) {
blockArgs, ok := opts.(*rpc_common.BlockArgs)
if ok {
return blockArgs, nil
}
switch s.version {
case V1, Eth:
fullTx, ok := opts.(bool)
if !ok {
return nil, fmt.Errorf("invalid type for block arguments")
}
return &rpc_common.BlockArgs{
WithSigners: false,
FullTx: fullTx,
InclStaking: true,
}, nil
case V2:
parsedBlockArgs := rpc_common.BlockArgs{}
if err := parsedBlockArgs.UnmarshalFromInterface(opts); err != nil {
return nil, err
}
return &parsedBlockArgs, nil
default:
return nil, ErrUnknownRPCVersion
}
}
func isBlockGreaterThanLatest(hmy *hmy.Harmony, blockNum rpc.BlockNumber) bool {
// rpc.BlockNumber is int64 (latest = -1. pending = -2) and currentBlockNum is uint64.
if blockNum == rpc.PendingBlockNumber {
@ -873,12 +872,6 @@ func (s *PublicBlockchainService) SetNodeToBackupMode(ctx context.Context, isBac
return s.hmy.NodeAPI.SetNodeBackupMode(isBackup), nil
}
func combineCacheKey(number uint64, version Version, blockArgs *rpc_common.BlockArgs) string {
// no need format blockArgs.Signers[] as a part of cache key
// because it's not input from rpc caller, it's calculate with blockArgs.WithSigners
return strconv.FormatUint(number, 10) + strconv.FormatInt(int64(version), 10) + strconv.FormatBool(blockArgs.WithSigners) + strconv.FormatBool(blockArgs.FullTx) + strconv.FormatBool(blockArgs.InclStaking)
}
const (
blockCacheSize = 2048
signersCacheSize = blockCacheSize
@ -887,7 +880,7 @@ const (
)
type (
// bcServiceHelper is the helper for block factory. Implements
// bcServiceHelper is the getHelper for block factory. Implements
// rpc_common.BlockDataProvider
bcServiceHelper struct {
version Version
@ -902,7 +895,7 @@ type (
}
)
func (s *PublicBlockchainService) helper() *bcServiceHelper {
func (s *PublicBlockchainService) newHelper() *bcServiceHelper {
signerCache, _ := lru.New(signersCacheSize)
stakingTxsCache, _ := lru.New(stakingTxsCacheSize)
leaderCache, _ := lru.New(leaderCacheSize)
@ -928,19 +921,6 @@ func (helper *bcServiceHelper) GetLeader(b *types.Block) string {
return leader
}
func (helper *bcServiceHelper) GetSigners(b *types.Block) ([]string, error) {
x, ok := helper.cache.signersCache.Get(b.NumberU64())
if ok && x != nil {
return x.([]string), nil
}
signers, err := getSigners(helper.hmy, b.NumberU64())
if err != nil {
return nil, errors.Wrap(err, "getSigners")
}
helper.cache.signersCache.Add(b.NumberU64(), signers)
return signers, nil
}
func (helper *bcServiceHelper) GetStakingTxs(b *types.Block) (interface{}, error) {
x, ok := helper.cache.stakingTxsCache.Get(b.NumberU64())
if ok && x != nil {
@ -977,20 +957,77 @@ func (helper *bcServiceHelper) GetStakingTxHashes(b *types.Block) []common.Hash
return res
}
func getSigners(hmy *hmy.Harmony, number uint64) ([]string, error) {
// signerData is the cached signing data for a block
type signerData struct {
signers []string // one address for signers
blsSigners []string // bls hex for signers
slots shard.SlotList // computed slots for epoch shard committee
mask *internal_bls.Mask // mask for the block
}
func (helper *bcServiceHelper) GetSigners(b *types.Block) ([]string, error) {
sd, err := helper.getSignerData(b.NumberU64())
if err != nil {
return nil, err
}
return sd.signers, nil
}
func (helper *bcServiceHelper) GetBLSSigners(bn uint64) ([]string, error) {
sd, err := helper.getSignerData(bn)
if err != nil {
return nil, err
}
return sd.blsSigners, nil
}
func (helper *bcServiceHelper) IsSigner(oneAddr string, bn uint64) (bool, error) {
sd, err := helper.getSignerData(bn)
if err != nil {
return false, err
}
for _, signer := range sd.signers {
if oneAddr == signer {
return true, nil
}
}
return false, nil
}
func (helper *bcServiceHelper) getSignerData(bn uint64) (*signerData, error) {
x, ok := helper.cache.signersCache.Get(bn)
if ok && x != nil {
return x.(*signerData), nil
}
sd, err := getSignerData(helper.hmy, bn)
if err != nil {
return nil, errors.Wrap(err, "getSignerData")
}
helper.cache.signersCache.Add(bn, sd)
return sd, nil
}
func getSignerData(hmy *hmy.Harmony, number uint64) (*signerData, error) {
slots, mask, err := hmy.GetBlockSigners(context.Background(), rpc.BlockNumber(number))
if err != nil {
return nil, err
}
signers := make([]string, 0, len(slots))
blsSigners := make([]string, 0, len(slots))
for _, validator := range slots {
oneAddress, err := internal_common.AddressToBech32(validator.EcdsaAddress)
if err != nil {
return nil, err
}
if ok, err := mask.KeyEnabled(validator.BLSPublicKey); err == nil && ok {
blsSigners = append(blsSigners, validator.BLSPublicKey.Hex())
signers = append(signers, oneAddress)
}
}
return signers, nil
return &signerData{
signers: signers,
blsSigners: blsSigners,
slots: slots,
mask: mask,
}, nil
}

2
rpc/staking.go
Unescape View File

@ -51,7 +51,7 @@ func (s *PublicStakingService) getBalanceByBlockNumber(
return balance, nil
}
// getAllValidatorInformation helper function to get all validator information for a given eth block number
// getAllValidatorInformation getHelper function to get all validator information for a given eth block number
func (s *PublicStakingService) getAllValidatorInformation(
ctx context.Context, page int, blockNum rpc.BlockNumber,
) ([]StructuredResponse, error) {

2
rpc/transaction.go
Unescape View File

@ -820,7 +820,7 @@ func EstimateGas(ctx context.Context, hmy *hmy.Harmony, args CallArgs, gasCap *b
}
cap = hi
// Create a helper to check if a gas allowance results in an executable transaction
// Create a getHelper to check if a gas allowance results in an executable transaction
executable := func(gas uint64) (bool, *core.ExecutionResult, error) {
args.Gas = (*hexutil.Uint64)(&gas)

Write Preview
Loading…
Cancel
Save