// Copyright 2015 The go-ethereum Authors

// This file is part of the go-ethereum library.

//

// The go-ethereum library is free software: you can redistribute it and/or modify

// it under the terms of the GNU Lesser General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// The go-ethereum library is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

// GNU Lesser General Public License for more details.

//

// You should have received a copy of the GNU Lesser General Public License

// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

package ethapi

import (

"context"

"errors"

"fmt"

"math/big"

"time"

"github.com/Fantom-foundation/lachesis-base/hash"

"github.com/Fantom-foundation/lachesis-base/inter/idx"

"github.com/davecgh/go-spew/spew"

"github.com/ethereum/go-ethereum/accounts"

"github.com/ethereum/go-ethereum/accounts/abi"

"github.com/ethereum/go-ethereum/accounts/keystore"

"github.com/ethereum/go-ethereum/accounts/scwallet"

"github.com/ethereum/go-ethereum/common"

"github.com/ethereum/go-ethereum/common/hexutil"

"github.com/ethereum/go-ethereum/common/math"

"github.com/ethereum/go-ethereum/consensus/ethash"

"github.com/ethereum/go-ethereum/core/state"

"github.com/ethereum/go-ethereum/core/types"

"github.com/ethereum/go-ethereum/core/vm"

"github.com/ethereum/go-ethereum/crypto"

"github.com/ethereum/go-ethereum/log"

"github.com/ethereum/go-ethereum/p2p"

"github.com/ethereum/go-ethereum/params"

"github.com/ethereum/go-ethereum/rlp"

"github.com/ethereum/go-ethereum/rpc"

"github.com/ethereum/go-ethereum/trie"

"github.com/tyler-smith/go-bip39"

"github.com/Fantom-foundation/go-opera/evmcore"

"github.com/Fantom-foundation/go-opera/gossip/gasprice"

"github.com/Fantom-foundation/go-opera/opera"

"github.com/Fantom-foundation/go-opera/utils/adapters/ethdb2kvdb"

"github.com/Fantom-foundation/go-opera/utils/compactdb"

"github.com/Fantom-foundation/go-opera/utils/signers/gsignercache"

"github.com/Fantom-foundation/go-opera/utils/signers/internaltx"

)

var (

noUncles = []evmcore.EvmHeader{}

)

// PublicEthereumAPI provides an API to access Ethereum related information.

// It offers only methods that operate on public data that is freely available to anyone.

type PublicEthereumAPI struct {

b Backend

}

// NewPublicEthereumAPI creates a new Ethereum protocol API.

func NewPublicEthereumAPI(b Backend) *PublicEthereumAPI {

return &PublicEthereumAPI{b}

}

// GasPrice returns a suggestion for a gas price for legacy transactions.

func (s *PublicEthereumAPI) GasPrice(ctx context.Context) (*hexutil.Big, error) {

tipcap := s.b.SuggestGasTipCap(ctx, gasprice.AsDefaultCertainty)

tipcap.Add(tipcap, s.b.MinGasPrice())

return (*hexutil.Big)(tipcap), nil

}

// MaxPriorityFeePerGas returns a suggestion for a gas tip cap for dynamic fee transactions.

func (s *PublicEthereumAPI) MaxPriorityFeePerGas(ctx context.Context) (*hexutil.Big, error) {

tipcap := s.b.SuggestGasTipCap(ctx, gasprice.AsDefaultCertainty)

return (*hexutil.Big)(tipcap), nil

}

type feeHistoryResult struct {

OldestBlock *hexutil.Big `json:"oldestBlock"`

Reward [][]*hexutil.Big `json:"reward,omitempty"`

BaseFee []*hexutil.Big `json:"baseFeePerGas,omitempty"`

GasUsedRatio []float64 `json:"gasUsedRatio"`

}

var errInvalidPercentile = errors.New("invalid reward percentile")

func (s *PublicEthereumAPI) FeeHistory(ctx context.Context, blockCount rpc.DecimalOrHex, lastBlock rpc.BlockNumber, rewardPercentiles []float64) (*feeHistoryResult, error) {

res := &feeHistoryResult{}

res.Reward = make([][]*hexutil.Big, 0, blockCount)

res.BaseFee = make([]*hexutil.Big, 0, blockCount)

res.GasUsedRatio = make([]float64, 0, blockCount)

res.OldestBlock = (*hexutil.Big)(new(big.Int))

// validate input parameters

if blockCount == 0 {

return res, nil

}

if blockCount > 1024 {

blockCount = 1024

}

for i, p := range rewardPercentiles {

if p < 0 || p > 100 {

return nil, fmt.Errorf("%w: %f", errInvalidPercentile, p)

}

if i > 0 && p < rewardPercentiles[i-1] {

return nil, fmt.Errorf("%w: #%d:%f > #%d:%f", errInvalidPercentile, i-1, rewardPercentiles[i-1], i, p)

}

}

last, err := s.b.ResolveRpcBlockNumberOrHash(ctx, rpc.BlockNumberOrHash{BlockNumber: &lastBlock})

if err != nil {

return nil, err

}

oldest := last

if oldest > idx.Block(blockCount) {

oldest -= idx.Block(blockCount - 1)

} else {

oldest = 0

}

baseFee := s.b.MinGasPrice()

tips := make([]*hexutil.Big, 0, len(rewardPercentiles))

for _, p := range rewardPercentiles {

tip := s.b.SuggestGasTipCap(ctx, uint64(gasprice.DecimalUnit*p/100.0))

tips = append(tips, (*hexutil.Big)(tip))

}

res.OldestBlock.ToInt().SetUint64(uint64(oldest))

for i := uint64(0); i < uint64(last-oldest+1); i++ {

res.Reward = append(res.Reward, tips)

res.BaseFee = append(res.BaseFee, (*hexutil.Big)(baseFee))

res.GasUsedRatio = append(res.GasUsedRatio, 0.99)

}

return res, nil

}

func (s *PublicEthereumAPI) EffectiveBaseFee(ctx context.Context) *hexutil.Big {

return (*hexutil.Big)(s.b.EffectiveMinGasPrice(ctx))

}

// Syncing returns true if node is syncing

func (s *PublicEthereumAPI) Syncing() (interface{}, error) {

progress := s.b.Progress()

// Return not syncing if the synchronisation already completed

if time.Since(progress.CurrentBlockTime.Time()) <= 90*time.Minute { // should be >> MaxEmitInterval

return false, nil

}

// Otherwise gather the block sync stats

return map[string]interface{}{

"startingBlock": hexutil.Uint64(0), // back-compatibility

"currentEpoch": hexutil.Uint64(progress.CurrentEpoch),

"currentBlock": hexutil.Uint64(progress.CurrentBlock),

"currentBlockHash": progress.CurrentBlockHash.Hex(),

"currentBlockTime": hexutil.Uint64(progress.CurrentBlockTime),

"highestBlock": hexutil.Uint64(progress.HighestBlock),

"highestEpoch": hexutil.Uint64(progress.HighestEpoch),

"pulledStates": hexutil.Uint64(0), // back-compatibility

"knownStates": hexutil.Uint64(0), // back-compatibility

}, nil

}

// PublicTxPoolAPI offers and API for the transaction pool. It only operates on data that is non confidential.

type PublicTxPoolAPI struct {

b Backend

}

// NewPublicTxPoolAPI creates a new tx pool service that gives information about the transaction pool.

func NewPublicTxPoolAPI(b Backend) *PublicTxPoolAPI {

return &PublicTxPoolAPI{b}

}

// Content returns the transactions contained within the transaction pool.

func (s *PublicTxPoolAPI) Content() map[string]map[string]map[string]*RPCTransaction {

content := map[string]map[string]map[string]*RPCTransaction{

"pending": make(map[string]map[string]*RPCTransaction),

"queued": make(map[string]map[string]*RPCTransaction),

}

pending, queue := s.b.TxPoolContent()

curHeader := s.b.CurrentBlock().Header()

// Flatten the pending transactions

for account, txs := range pending {

dump := make(map[string]*RPCTransaction)

for _, tx := range txs {

dump[fmt.Sprintf("%d", tx.Nonce())] = newRPCPendingTransaction(tx, curHeader.BaseFee)

}

content["pending"][account.Hex()] = dump

}

// Flatten the queued transactions

for account, txs := range queue {

dump := make(map[string]*RPCTransaction)

for _, tx := range txs {

dump[fmt.Sprintf("%d", tx.Nonce())] = newRPCPendingTransaction(tx, curHeader.BaseFee)

}

content["queued"][account.Hex()] = dump

}

return content

}

// ContentFrom returns the transactions contained within the transaction pool.

func (s *PublicTxPoolAPI) ContentFrom(addr common.Address) map[string]map[string]*RPCTransaction {

content := make(map[string]map[string]*RPCTransaction, 2)

pending, queue := s.b.TxPoolContentFrom(addr)

curHeader := s.b.CurrentBlock().Header()

// Build the pending transactions

dump := make(map[string]*RPCTransaction, len(pending))

for _, tx := range pending {

dump[fmt.Sprintf("%d", tx.Nonce())] = newRPCPendingTransaction(tx, curHeader.BaseFee)

}

content["pending"] = dump

// Build the queued transactions

dump = make(map[string]*RPCTransaction, len(queue))

for _, tx := range queue {

dump[fmt.Sprintf("%d", tx.Nonce())] = newRPCPendingTransaction(tx, curHeader.BaseFee)

}

content["queued"] = dump

return content

}

// Status returns the number of pending and queued transaction in the pool.

func (s *PublicTxPoolAPI) Status() map[string]hexutil.Uint {

pending, queue := s.b.Stats()

return map[string]hexutil.Uint{

"pending": hexutil.Uint(pending),

"queued": hexutil.Uint(queue),

}

}

// Inspect retrieves the content of the transaction pool and flattens it into an

// easily inspectable list.

func (s *PublicTxPoolAPI) Inspect() map[string]map[string]map[string]string {

content := map[string]map[string]map[string]string{

"pending": make(map[string]map[string]string),

"queued": make(map[string]map[string]string),

}

pending, queue := s.b.TxPoolContent()

// Define a formatter to flatten a transaction into a string

var format = func(tx *types.Transaction) string {

if to := tx.To(); to != nil {

return fmt.Sprintf("%s: %v wei + %v gas × %v wei", tx.To().Hex(), tx.Value(), tx.Gas(), tx.GasPrice())

}

return fmt.Sprintf("contract creation: %v wei + %v gas × %v wei", tx.Value(), tx.Gas(), tx.GasPrice())

}

// Flatten the pending transactions

for account, txs := range pending {

dump := make(map[string]string)

for _, tx := range txs {

dump[fmt.Sprintf("%d", tx.Nonce())] = format(tx)

}

content["pending"][account.Hex()] = dump

}

// Flatten the queued transactions

for account, txs := range queue {

dump := make(map[string]string)

for _, tx := range txs {

dump[fmt.Sprintf("%d", tx.Nonce())] = format(tx)

}

content["queued"][account.Hex()] = dump

}

return content

}

// PublicAccountAPI provides an API to access accounts managed by this node.

// It offers only methods that can retrieve accounts.

type PublicAccountAPI struct {

am *accounts.Manager

}

// NewPublicAccountAPI creates a new PublicAccountAPI.

func NewPublicAccountAPI(am *accounts.Manager) *PublicAccountAPI {

return &PublicAccountAPI{am: am}

}

// Accounts returns the collection of accounts this node manages

func (s *PublicAccountAPI) Accounts() []common.Address {

return s.am.Accounts()

}

// PrivateAccountAPI provides an API to access accounts managed by this node.

// It offers methods to create, (un)lock en list accounts. Some methods accept

// passwords and are therefore considered private by default.

type PrivateAccountAPI struct {

am *accounts.Manager

nonceLock *AddrLocker

b Backend

}

// NewPrivateAccountAPI create a new PrivateAccountAPI.

func NewPrivateAccountAPI(b Backend, nonceLock *AddrLocker) *PrivateAccountAPI {

return &PrivateAccountAPI{

am: b.AccountManager(),

nonceLock: nonceLock,

b: b,

}

}

// ListAccounts will return a list of addresses for accounts this node manages.

func (s *PrivateAccountAPI) ListAccounts() []common.Address {

return s.am.Accounts()

}

// RawWallet is a JSON representation of an accounts.Wallet interface, with its

// data contents extracted into plain fields.

type RawWallet struct {

URL string `json:"url"`

Status string `json:"status"`

Failure string `json:"failure,omitempty"`

Accounts []accounts.Account `json:"accounts,omitempty"`

}

// ListWallets will return a list of wallets this node manages.

func (s *PrivateAccountAPI) ListWallets() []RawWallet {

wallets := make([]RawWallet, 0) // return [] instead of nil if empty

for _, wallet := range s.am.Wallets() {

status, failure := wallet.Status()

raw := RawWallet{

URL: wallet.url().String(),

Status: status,

Accounts: wallet.Accounts(),

}

if failure != nil {

raw.Failure = failure.Error()

}

wallets = append(wallets, raw)

}

return wallets

}

// OpenWallet initiates a hardware wallet opening procedure, establishing a USB

// connection and attempting to authenticate via the provided passphrase. Note,

// the method may return an extra challenge requiring a second open (e.g. the

// Trezor PIN matrix challenge).

func (s *PrivateAccountAPI) OpenWallet(url string, passphrase *string) error {

wallet, err := s.am.Wallet(url)

if err != nil {

return err

}

pass := ""

if passphrase != nil {

pass = *passphrase

}

return wallet.Open(pass)

}

// DeriveAccount requests a HD wallet to derive a new account, optionally pinning

// it for later reuse.

func (s *PrivateAccountAPI) DeriveAccount(url string, path string, pin *bool) (accounts.Account, error) {

wallet, err := s.am.Wallet(url)

if err != nil {

return accounts.Account{}, err

}

derivPath, err := accounts.ParseDerivationPath(path)

if err != nil {

return accounts.Account{}, err

}

if pin == nil {

pin = new(bool)

}

return wallet.Derive(derivPath, *pin)

}

// NewAccount will create a new account and returns the address for the new account.

func (s *PrivateAccountAPI) NewAccount(password string) (common.Address, error) {

ks, err := fetchKeystore(s.am)

if err != nil {

return common.Address{}, err

}

acc, err := ks.NewAccount(password)

if err == nil {

log.Info("Your new key was generated", "address", acc.Address)

log.Warn("Please backup your key file!", "path", acc.URL.Path)

log.Warn("Please remember your password!")

return acc.Address, nil

}

return common.Address{}, err

}

// fetchKeystore retrieves the encrypted keystore from the account manager.

func fetchKeystore(am *accounts.Manager) (*keystore.KeyStore, error) {

if ks := am.Backends(keystore.KeyStoreType); len(ks) > 0 {

return ks[0].(*keystore.KeyStore), nil

}

return nil, errors.New("local keystore not used")

}

// ImportRawKey stores the given hex encoded ECDSA key into the key directory,

// encrypting it with the passphrase.

func (s *PrivateAccountAPI) ImportRawKey(privkey string, password string) (common.Address, error) {

key, err := crypto.HexToECDSA(privkey)

if err != nil {

return common.Address{}, err

}

ks, err := fetchKeystore(s.am)

if err != nil {

return common.Address{}, err

}

acc, err := ks.ImportECDSA(key, password)

return acc.Address, err

}

// UnlockAccount will unlock the account associated with the given address with

// the given password for duration seconds. If duration is nil it will use a

// default of 300 seconds. It returns an indication if the account was unlocked.

func (s *PrivateAccountAPI) UnlockAccount(ctx context.Context, addr common.Address, password string, duration *uint64) (bool, error) {

// When the API is exposed by external RPC(http, ws etc), unless the user

// explicitly specifies to allow the insecure account unlocking, otherwise

// it is disabled.

if s.b.ExtRPCEnabled() && !s.b.AccountManager().Config().InsecureUnlockAllowed {

return false, errors.New("account unlock with HTTP access is forbidden")

}

const max = uint64(time.Duration(math.MaxInt64) / time.Second)

var d time.Duration

if duration == nil {

d = 300 * time.Second

} else if *duration > max {

return false, errors.New("unlock duration too large")

} else {

d = time.Duration(*duration) * time.Second

}

ks, err := fetchKeystore(s.am)

if err != nil {

return false, err

}

err = ks.TimedUnlock(accounts.Account{Address: addr}, password, d)

if err != nil {

log.Warn("Failed account unlock attempt", "address", addr, "err", err)

}

return err == nil, err

}

// LockAccount will lock the account associated with the given address when it's unlocked.

func (s *PrivateAccountAPI) LockAccount(addr common.Address) bool {

if ks, err := fetchKeystore(s.am); err == nil {

return ks.Lock(addr) == nil

}

return false

}

// signTransaction sets defaults and signs the given transaction

// NOTE: the caller needs to ensure that the nonceLock is held, if applicable,

// and release it after the transaction has been submitted to the tx pool

func (s *PrivateAccountAPI) signTransaction(ctx context.Context, args *TransactionArgs, passwd string) (*types.Transaction, error) {

// Look up the wallet containing the requested signer

account := accounts.Account{Address: args.from()}

wallet, err := s.am.Find(account)

if err != nil {

return nil, err

}

// Set some sanity defaults and terminate on failure

if err := args.setDefaults(ctx, s.b); err != nil {

return nil, err

}

// Assemble the transaction and sign with the wallet

tx := args.toTransaction()

return wallet.SignTxWithPassphrase(account, passwd, tx, s.b.ChainConfig().ChainID)

}

// SendTransaction will create a transaction from the given arguments and

// tries to sign it with the key associated with args.From. If the given

// passwd isn't able to decrypt the key it fails.

func (s *PrivateAccountAPI) SendTransaction(ctx context.Context, args TransactionArgs, passwd string) (common.Hash, error) {

if args.Nonce == nil {

// Hold the addresse's mutex around signing to prevent concurrent assignment of

// the same nonce to multiple accounts.

s.nonceLock.LockAddr(args.from())

defer s.nonceLock.UnlockAddr(args.from())

}

signed, err := s.signTransaction(ctx, &args, passwd)

if err != nil {

log.Warn("Failed transaction send attempt", "from", args.from(), "to", args.To, "value", args.Value.ToInt(), "err", err)

return common.Hash{}, err

}

return SubmitTransaction(ctx, s.b, signed)

}

// SignTransaction will create a transaction from the given arguments and

// tries to sign it with the key associated with args.From. If the given passwd isn't

// able to decrypt the key it fails. The transaction is returned in RLP-form, not broadcast

// to other nodes

func (s *PrivateAccountAPI) SignTransaction(ctx context.Context, args TransactionArgs, passwd string) (*SignTransactionResult, error) {

// No need to obtain the noncelock mutex, since we won't be sending this

// tx into the transaction pool, but right back to the user

if args.From == nil {

return nil, fmt.Errorf("sender not specified")

}

if args.Gas == nil {

return nil, fmt.Errorf("gas not specified")

}

if args.GasPrice == nil && (args.MaxFeePerGas == nil || args.MaxPriorityFeePerGas == nil) {

return nil, fmt.Errorf("missing gasPrice or maxFeePerGas/maxPriorityFeePerGas")

}

if args.Nonce == nil {

return nil, fmt.Errorf("nonce not specified")

}

// Before actually signing the transaction, ensure the transaction fee is reasonable.

tx := args.toTransaction()

if err := checkTxFee(tx.GasPrice(), tx.Gas(), s.b.RPCTxFeeCap()); err != nil {

return nil, err

}

signed, err := s.signTransaction(ctx, &args, passwd)

if err != nil {

log.Warn("Failed transaction sign attempt", "from", args.from(), "to", args.To, "value", args.Value.ToInt(), "err", err)

return nil, err

}

data, err := signed.MarshalBinary()

if err != nil {

return nil, err

}

return &SignTransactionResult{data, signed}, nil

}

// Sign calculates an Ethereum ECDSA signature for:

// keccack256("\x19Ethereum Signed Message:\n" + len(message) + message))

//

// Note, the produced signature conforms to the secp256k1 curve R, S and V values,

// where the V value will be 27 or 28 for legacy reasons.

//

// The key used to calculate the signature is decrypted with the given password.

//

// https://github.com/ethereum/go-ethereum/wiki/Management-APIs#personal_sign

func (s *PrivateAccountAPI) Sign(ctx context.Context, data hexutil.Bytes, addr common.Address, passwd string) (hexutil.Bytes, error) {

// Look up the wallet containing the requested signer

account := accounts.Account{Address: addr}

wallet, err := s.b.AccountManager().Find(account)

if err != nil {

return nil, err

}

// Assemble sign the data with the wallet

signature, err := wallet.SignTextWithPassphrase(account, passwd, data)

if err != nil {

log.Warn("Failed data sign attempt", "address", addr, "err", err)

return nil, err

}

signature[crypto.RecoveryIDOffset] += 27 // Transform V from 0/1 to 27/28 according to the yellow paper

return signature, nil

}

// EcRecover returns the address for the account that was used to create the signature.

// Note, this function is compatible with eth_sign and personal_sign. As such it recovers

// the address of:

// hash = keccak256("\x19Ethereum Signed Message:\n"${message length}${message})

// addr = ecrecover(hash, signature)

//

// Note, the signature must conform to the secp256k1 curve R, S and V values, where

// the V value must be 27 or 28 for legacy reasons.

//

// https://github.com/ethereum/go-ethereum/wiki/Management-APIs#personal_ecRecover

func (s *PrivateAccountAPI) EcRecover(ctx context.Context, data, sig hexutil.Bytes) (common.Address, error) {

if len(sig) != crypto.SignatureLength {

return common.Address{}, fmt.Errorf("signature must be %d bytes long", crypto.SignatureLength)

}

if sig[crypto.RecoveryIDOffset] != 27 && sig[crypto.RecoveryIDOffset] != 28 {

return common.Address{}, fmt.Errorf("invalid Ethereum signature (V is not 27 or 28)")

}

sig[crypto.RecoveryIDOffset] -= 27 // Transform yellow paper V from 27/28 to 0/1

rpk, err := crypto.SigToPub(accounts.TextHash(data), sig)

if err != nil {

return common.Address{}, err

}

return crypto.PubkeyToAddress(*rpk), nil

}

// SignAndSendTransaction was renamed to SendTransaction. This method is deprecated

// and will be removed in the future. It primary goal is to give clients time to update.

func (s *PrivateAccountAPI) SignAndSendTransaction(ctx context.Context, args TransactionArgs, passwd string) (common.Hash, error) {

return s.SendTransaction(ctx, args, passwd)

}

// InitializeWallet initializes a new wallet at the provided URL, by generating and returning a new private key.

func (s *PrivateAccountAPI) InitializeWallet(ctx context.Context, url string) (string, error) {

wallet, err := s.am.Wallet(url)

if err != nil {

return "", err

}

entropy, err := bip39.NewEntropy(256)

if err != nil {

return "", err

}

mnemonic, err := bip39.NewMnemonic(entropy)

if err != nil {

return "", err

}

seed := bip39.NewSeed(mnemonic, "")

switch wallet := wallet.(type) {

case *scwallet.Wallet:

return mnemonic, wallet.Initialize(seed)

default:

return "", fmt.Errorf("specified wallet does not support initialization")

}

}

// Unpair deletes a pairing between wallet and geth.

func (s *PrivateAccountAPI) Unpair(ctx context.Context, url string, pin string) error {

wallet, err := s.am.Wallet(url)

if err != nil {

return err

}

switch wallet := wallet.(type) {

case *scwallet.Wallet:

return wallet.Unpair([]byte(pin))

default:

return fmt.Errorf("specified wallet does not support pairing")

}

}

// PublicBlockChainAPI provides an API to access the Ethereum blockchain.

// It offers only methods that operate on public data that is freely available to anyone.

type PublicBlockChainAPI struct {

b Backend

}

// NewPublicBlockChainAPI creates a new Ethereum blockchain API.

func NewPublicBlockChainAPI(b Backend) *PublicBlockChainAPI {

return &PublicBlockChainAPI{b}

}

// CurrentEpoch returns current epoch number.

func (s *PublicBlockChainAPI) CurrentEpoch(ctx context.Context) hexutil.Uint64 {

return hexutil.Uint64(s.b.CurrentEpoch(ctx))

}

// GetRules returns network rules for an epoch

func (s *PublicBlockChainAPI) GetRules(ctx context.Context, epoch rpc.BlockNumber) (*opera.Rules, error) {

_, es, err := s.b.GetEpochBlockState(ctx, epoch)

if err != nil {

return nil, err

}

if es == nil {

return nil, nil

}

return &es.Rules, nil

}

// GetEpochBlock returns block height in a beginning of an epoch

func (s *PublicBlockChainAPI) GetEpochBlock(ctx context.Context, epoch rpc.BlockNumber) (hexutil.Uint64, error) {

bs, _, err := s.b.GetEpochBlockState(ctx, epoch)

if err != nil {

return 0, err

}

if bs == nil {

return 0, nil

}

return hexutil.Uint64(bs.LastBlock.Idx), nil

}

// ChainId is the EIP-155 replay-protection chain id for the current ethereum chain config.

func (api *PublicBlockChainAPI) ChainId() (*hexutil.Big, error) {

// if current block is at or past the EIP-155 replay-protection fork block, return chainID from config

if config := api.b.ChainConfig(); config.IsEIP155(api.b.CurrentBlock().Number) {

return (*hexutil.Big)(config.ChainID), nil

}

return nil, fmt.Errorf("chain not synced beyond EIP-155 replay-protection fork block")

}

// BlockNumber returns the block number of the chain head.

func (s *PublicBlockChainAPI) BlockNumber() hexutil.Uint64 {

header, _ := s.b.HeaderByNumber(context.Background(), rpc.LatestBlockNumber) // latest header should always be available

return hexutil.Uint64(header.Number.Uint64())

}

// GetBalance returns the amount of wei for the given address in the state of the

// given block number. The rpc.LatestBlockNumber and rpc.PendingBlockNumber meta

// block numbers are also allowed.

func (s *PublicBlockChainAPI) GetBalance(ctx context.Context, address common.Address, blockNrOrHash rpc.BlockNumberOrHash) (*hexutil.Big, error) {

state, _, err := s.b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)

if state == nil || err != nil {

return nil, err

}

return (*hexutil.Big)(state.GetBalance(address)), state.Error()

}

// AccountResult is result struct for GetProof

type AccountResult struct {

Address common.Address `json:"address"`

AccountProof []string `json:"accountProof"`

Balance *hexutil.Big `json:"balance"`

CodeHash common.Hash `json:"codeHash"`

Nonce hexutil.Uint64 `json:"nonce"`

StorageHash common.Hash `json:"storageHash"`

StorageProof []StorageResult `json:"storageProof"`

}

// StorageResult is result struct for GetProof

type StorageResult struct {

Key string `json:"key"`

Value *hexutil.Big `json:"value"`

Proof []string `json:"proof"`

}

// GetProof returns the Merkle-proof for a given account and optionally some storage keys.

func (s *PublicBlockChainAPI) GetProof(ctx context.Context, address common.Address, storageKeys []string, blockNrOrHash rpc.BlockNumberOrHash) (*AccountResult, error) {

state, _, err := s.b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)

if state == nil || err != nil {

return nil, err

}

storageTrie := state.StorageTrie(address)

storageHash := types.EmptyRootHash

codeHash := state.GetCodeHash(address)

storageProof := make([]StorageResult, len(storageKeys))

// if we have a storageTrie, (which means the account exists), we can update the storagehash

if storageTrie != nil {

storageHash = storageTrie.Hash()

} else {

// no storageTrie means the account does not exist, so the codeHash is the hash of an empty bytearray.

codeHash = crypto.Keccak256Hash(nil)

}

// create the proof for the storageKeys

for i, key := range storageKeys {

if storageTrie != nil {

proof, storageError := state.GetStorageProof(address, common.HexToHash(key))

if storageError != nil {

return nil, storageError

}

storageProof[i] = StorageResult{key, (*hexutil.Big)(state.GetState(address, common.HexToHash(key)).Big()), toHexSlice(proof)}

} else {

storageProof[i] = StorageResult{key, &hexutil.Big{}, []string{}}

}

}

// create the accountProof

accountProof, proofErr := state.GetProof(address)

if proofErr != nil {

return nil, proofErr

}

return &AccountResult{

Address: address,

AccountProof: toHexSlice(accountProof),

Balance: (*hexutil.Big)(state.GetBalance(address)),

CodeHash: codeHash,

Nonce: hexutil.Uint64(state.GetNonce(address)),

StorageHash: storageHash,

StorageProof: storageProof,

}, state.Error()

}

// GetHeaderByNumber returns the requested canonical block header.

// * When blockNr is -1 the chain head is returned.

// * When blockNr is -2 the pending chain head is returned.

func (s *PublicBlockChainAPI) GetHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (map[string]interface{}, error) {

header, err := s.b.HeaderByNumber(ctx, number)

if header != nil && err == nil {

response := s.rpcMarshalHeader(header, s.calculateExtBlockApi(ctx, number))

if number == rpc.PendingBlockNumber {

// Pending header need to nil out a few fields

for _, field := range []string{"hash", "nonce", "miner"} {

response[field] = nil

}

}

return response, err

}

return nil, err

}

// GetHeaderByHash returns the requested header by hash.

func (s *PublicBlockChainAPI) GetHeaderByHash(ctx context.Context, hash common.Hash) map[string]interface{} {

header, _ := s.b.HeaderByHash(ctx, hash)

if header != nil {

return s.rpcMarshalHeader(header, s.calculateExtBlockApi(ctx, rpc.BlockNumber(header.Number.Uint64())))

}

return nil

}

func (s *PublicBlockChainAPI) calculateExtBlockApi(ctx context.Context, blkNumber rpc.BlockNumber) extBlockApi {

var ext extBlockApi

if s.b.CalcBlockExtApi() && blkNumber != rpc.EarliestBlockNumber {

receipts, err := s.b.GetReceiptsByNumber(ctx, blkNumber)

if err != nil {

return ext

}

if receipts.Len() != 0 {

ext.receiptsRoot = types.DeriveSha(receipts, trie.NewStackTrie(nil))

ext.bloom = types.CreateBloom(receipts)

} else {

ext.receiptsRoot = types.EmptyRootHash

}

}

return ext

}

// GetBlockByNumber returns the requested canonical block.

// * When blockNr is -1 the chain head is returned.

// * When blockNr is -2 the pending chain head is returned.

// * When fullTx is true all transactions in the block are returned, otherwise

// only the transaction hash is returned.

func (s *PublicBlockChainAPI) GetBlockByNumber(ctx context.Context, number rpc.BlockNumber, fullTx bool) (map[string]interface{}, error) {

block, err := s.b.BlockByNumber(ctx, number)

if block != nil && err == nil {

response, err := s.rpcMarshalBlock(block, s.calculateExtBlockApi(ctx, number), true, fullTx)

if err == nil && number == rpc.PendingBlockNumber {

// Pending blocks need to nil out a few fields

for _, field := range []string{"hash", "nonce", "miner"} {

response[field] = nil

}

}

return response, err

}

return nil, err

}

// GetBlockByHash returns the requested block. When fullTx is true all transactions in the block are returned in full

// detail, otherwise only the transaction hash is returned.

func (s *PublicBlockChainAPI) GetBlockByHash(ctx context.Context, hash common.Hash, fullTx bool) (map[string]interface{}, error) {

block, err := s.b.BlockByHash(ctx, hash)

if block != nil {

return s.rpcMarshalBlock(block, s.calculateExtBlockApi(ctx, rpc.BlockNumber(block.NumberU64())), true, fullTx)

}

return nil, err

}

// GetUncleByBlockNumberAndIndex returns the uncle block for the given block hash and index. When fullTx is true

// all transactions in the block are returned in full detail, otherwise only the transaction hash is returned.

func (s *PublicBlockChainAPI) GetUncleByBlockNumberAndIndex(ctx context.Context, blockNr rpc.BlockNumber, index hexutil.Uint) (map[string]interface{}, error) {

block, err := s.b.BlockByNumber(ctx, blockNr)

if block != nil {

log.Debug("Requested uncle not found", "number", blockNr, "hash", block.Hash, "index", index)

return nil, nil

}

return nil, err

}

// GetUncleByBlockHashAndIndex returns the uncle block for the given block hash and index. When fullTx is true

// all transactions in the block are returned in full detail, otherwise only the transaction hash is returned.

func (s *PublicBlockChainAPI) GetUncleByBlockHashAndIndex(ctx context.Context, blockHash common.Hash, index hexutil.Uint) (map[string]interface{}, error) {

block, err := s.b.BlockByHash(ctx, blockHash)

if block != nil {

log.Debug("Requested uncle not found", "number", block.Number, "hash", blockHash, "index", index)

return nil, nil

}

return nil, err

}

// GetUncleCountByBlockNumber returns number of uncles in the block for the given block number

func (s *PublicBlockChainAPI) GetUncleCountByBlockNumber(ctx context.Context, blockNr rpc.BlockNumber) *hexutil.Uint {

if block, _ := s.b.BlockByNumber(ctx, blockNr); block != nil {

n := hexutil.Uint(len(noUncles))

return &n

}

return nil

}

// GetUncleCountByBlockHash returns number of uncles in the block for the given block hash

func (s *PublicBlockChainAPI) GetUncleCountByBlockHash(ctx context.Context, blockHash common.Hash) *hexutil.Uint {

if block, _ := s.b.BlockByHash(ctx, blockHash); block != nil {

n := hexutil.Uint(len(noUncles))

return &n

}

return nil

}

// GetCode returns the code stored at the given address in the state for the given block number.

func (s *PublicBlockChainAPI) GetCode(ctx context.Context, address common.Address, blockNrOrHash rpc.BlockNumberOrHash) (hexutil.Bytes, error) {

state, _, err := s.b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)

if state == nil || err != nil {

return nil, err

}

code := state.GetCode(address)

return code, state.Error()

}

// GetStorageAt returns the storage from the state at the given address, key and

// block number. The rpc.LatestBlockNumber and rpc.PendingBlockNumber meta block

// numbers are also allowed.

func (s *PublicBlockChainAPI) GetStorageAt(ctx context.Context, address common.Address, key string, blockNr rpc.BlockNumberOrHash) (hexutil.Bytes, error) {

state, _, err := s.b.StateAndHeaderByNumberOrHash(ctx, blockNr)

if state == nil || err != nil {

return nil, err

}

res := state.GetState(address, common.HexToHash(key))

return res[:], state.Error()

}

// OverrideAccount indicates the overriding fields of account during the execution

// of a message call.

// Note, state and stateDiff can't be specified at the same time. If state is

// set, message execution will only use the data in the given state. Otherwise

// if statDiff is set, all diff will be applied first and then execute the call

// message.

type OverrideAccount struct {

Nonce *hexutil.Uint64 `json:"nonce"`

Code *hexutil.Bytes `json:"code"`

Balance **hexutil.Big `json:"balance"`

State *map[common.Hash]common.Hash `json:"state"`

StateDiff *map[common.Hash]common.Hash `json:"stateDiff"`

}

// StateOverride is the collection of overridden accounts.

type StateOverride map[common.Address]OverrideAccount

// Apply overrides the fields of specified accounts into the given state.

func (diff *StateOverride) Apply(state *state.StateDB) error {

if diff == nil {

return nil

}

for addr, account := range *diff {

// Override account nonce.

if account.Nonce != nil {

state.SetNonce(addr, uint64(*account.Nonce))

}

// Override account(contract) code.

if account.Code != nil {

state.SetCode(addr, *account.Code)

}

// Override account balance.

if account.Balance != nil {

state.SetBalance(addr, (*big.Int)(*account.Balance))

}

if account.State != nil && account.StateDiff != nil {

return fmt.Errorf("account %s has both 'state' and 'stateDiff'", addr.Hex())

}

// Replace entire state if caller requires.

if account.State != nil {

state.SetStorage(addr, *account.State)

}

// Apply state diff into specified accounts.

if account.StateDiff != nil {

for key, value := range *account.StateDiff {

state.SetState(addr, key, value)

}

}

}

return nil

}

func DoCall(ctx context.Context, b Backend, args TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, overrides *StateOverride, timeout time.Duration, globalGasCap uint64) (*evmcore.ExecutionResult, error) {

defer func(start time.Time) { log.Debug("Executing EVM call finished", "runtime", time.Since(start)) }(time.Now())

state, header, err := b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)

if state == nil || err != nil {

return nil, err

}

if err := overrides.Apply(state); err != nil {

return nil, err

}

// 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

if timeout > 0 {

ctx, cancel = context.WithTimeout(ctx, timeout)

} else {

ctx, cancel = context.WithCancel(ctx)

}

// Make sure the context is cancelled when the call has completed

// this makes sure resources are cleaned up.

defer cancel()

// Get a new instance of the EVM.

msg, err := args.ToMessage(globalGasCap, header.BaseFee)

if err != nil {

return nil, err

}

vmConfig := opera.DefaultVMConfig

vmConfig.NoBaseFee = true

evm, vmError, err := b.GetEVM(ctx, msg, state, header, &vmConfig)

if err != nil {

return nil, err

}

// Wait for the context to be done and cancel the evm. Even if the

// EVM has finished, cancelling may be done (repeatedly)

go func() {

<-ctx.Done()

evm.Cancel()

}()

// Execute the message.

gp := new(evmcore.GasPool).AddGas(math.MaxUint64)

result, err := evmcore.ApplyMessage(evm, msg, gp)

if err := vmError(); err != nil {

return nil, err

}

// If the timer caused an abort, return an appropriate error message

if evm.Cancelled() {

return nil, fmt.Errorf("execution aborted (timeout = %v)", timeout)

}

if err != nil {