implement extended evm service interface (#17496)

* implement extended evm service interface

* bump evm, solana, common

* make tidy

* generate

* tidy

* generate

* gen config docs

* add tests

* update common

* add tests

* bump common

* bump common

* bump deps

* bump deps

* make config docs

* bump common

* bump common

* update types

* bump deps

* tidy

* bump depl framework

* make generate

* revert modified

* tidy

* rm mocked

* bump common

* fix tests

* bump common

* bump dependncies

* bump dependencies

Author: Unheilbar

core/services/relay/evm/evm.go

@@ -35,7 +35,6 @@ import (
 	"github.com/smartcontractkit/chainlink-common/pkg/sqlutil"
 	commontypes "github.com/smartcontractkit/chainlink-common/pkg/types"
 	cciptypes "github.com/smartcontractkit/chainlink-common/pkg/types/ccip"
-	commonevmtypes "github.com/smartcontractkit/chainlink-common/pkg/types/chains/evm"
 	coretypes "github.com/smartcontractkit/chainlink-common/pkg/types/core"
 	"github.com/smartcontractkit/chainlink-evm/pkg/config/chaintype"
 	"github.com/smartcontractkit/chainlink-evm/pkg/keys"
@@ -1002,10 +1001,6 @@ func (r *Relayer) EVM() (commontypes.EVMService, error) {
 	return r, nil
 }
 
-func (r *Relayer) GetTransactionFee(ctx context.Context, transactionID string) (*commonevmtypes.TransactionFee, error) {
-	return r.chain.TxManager().GetTransactionFee(ctx, transactionID)
-}
-
 func (r *Relayer) NewMedianProvider(ctx context.Context, rargs commontypes.RelayArgs, pargs commontypes.PluginArgs) (commontypes.MedianProvider, error) {
 	lggr := logger.Sugared(r.lggr).Named("MedianProvider").Named(rargs.ExternalJobID.String())
 	relayOpts := types.NewRelayOpts(rargs)

core/services/relay/evm/evm_service.go

@@ -0,0 +1,316 @@
+package evm
+
+import (
+	"context"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/common"
+	gethtypes "github.com/ethereum/go-ethereum/core/types"
+	"github.com/pkg/errors"
+	commontypes "github.com/smartcontractkit/chainlink-common/pkg/types"
+	"github.com/smartcontractkit/chainlink-common/pkg/types/chains/evm"
+	evmtypes "github.com/smartcontractkit/chainlink-common/pkg/types/chains/evm"
+
+	"github.com/smartcontractkit/chainlink-common/pkg/types/query"
+	"github.com/smartcontractkit/chainlink-common/pkg/types/query/primitives"
+	"github.com/smartcontractkit/chainlink-evm/pkg/heads"
+	"github.com/smartcontractkit/chainlink-evm/pkg/logpoller"
+	"github.com/smartcontractkit/chainlink-evm/pkg/types"
+	"github.com/smartcontractkit/chainlink-framework/chains"
+)
+
+// Direct RPC
+func (r *Relayer) CallContract(ctx context.Context, msg *evmtypes.CallMsg, blockNumber *big.Int) ([]byte, error) {
+	return r.chain.Client().CallContract(ctx, toEthMsg(msg), blockNumber)
+}
+
+func (r *Relayer) FilterLogs(ctx context.Context, filterQuery evmtypes.FilterQuery) ([]*evmtypes.Log, error) {
+	logs, err := r.chain.Client().FilterLogs(ctx, convertEthFilter(filterQuery))
+	if err != nil {
+		return nil, err
+	}
+
+	ret := make([]*evmtypes.Log, 0, len(logs))
+
+	for _, l := range logs {
+		ret = append(ret, convertLog(&l))
+	}
+
+	return ret, nil
+}
+
+func (r *Relayer) BalanceAt(ctx context.Context, account evmtypes.Address, blockNumber *big.Int) (*big.Int, error) {
+	return r.chain.Client().BalanceAt(ctx, account, blockNumber)
+}
+
+func (r *Relayer) EstimateGas(ctx context.Context, call *evmtypes.CallMsg) (uint64, error) {
+	return r.chain.Client().EstimateGas(ctx, toEthMsg(call))
+}
+
+func (r *Relayer) TransactionByHash(ctx context.Context, hash evmtypes.Hash) (*evmtypes.Transaction, error) {
+	tx, err := r.chain.Client().TransactionByHash(ctx, hash)
+	if err != nil {
+		return nil, err
+	}
+
+	return convertTransaction(tx), nil
+}
+
+func (r *Relayer) TransactionReceipt(ctx context.Context, txHash evmtypes.Hash) (*evmtypes.Receipt, error) {
+	receipt, err := r.chain.Client().TransactionReceipt(ctx, txHash)
+	if err != nil {
+		return nil, err
+	}
+
+	return convertReceipt(receipt), nil
+}
+
+// ChainService
+func (r *Relayer) GetTransactionFee(ctx context.Context, transactionID commontypes.IdempotencyKey) (*evmtypes.TransactionFee, error) {
+	return r.chain.TxManager().GetTransactionFee(ctx, transactionID)
+}
+
+func (r *Relayer) LatestAndFinalizedHead(ctx context.Context) (evmtypes.Head, evmtypes.Head, error) {
+	latest, finalized, err := r.chain.HeadTracker().LatestAndFinalizedBlock(ctx)
+	if err != nil {
+		return evmtypes.Head{}, evmtypes.Head{}, err
+	}
+
+	return convertHead(latest), convertHead(finalized), nil
+}
+
+func (r *Relayer) QueryTrackedLogs(ctx context.Context, filterQuery []query.Expression,
+	limitAndSort query.LimitAndSort, confidenceLevel primitives.ConfidenceLevel) ([]*evmtypes.Log, error) {
+	// TODO move evm specific expressions to common
+	// TODO check if required filters[event sig and address] are set
+	// TODO specify query name BCFR-1328
+	// BCFR-1328
+	conformations := confidenceToConformations(confidenceLevel)
+	filterQuery = append(filterQuery, logpoller.NewConfirmationsFilter(conformations))
+	logs, err := r.chain.LogPoller().FilteredLogs(ctx, filterQuery, limitAndSort, "")
+
+	if err != nil {
+		return nil, err
+	}
+
+	return convertLPLogs(logs), nil
+}
+
+func (r *Relayer) RegisterLogTracking(ctx context.Context, filter evmtypes.LPFilterQuery) error {
+	lpfilter, err := convertLPFilter(filter)
+	if err != nil {
+		return err
+	}
+	if r.chain.LogPoller().HasFilter(lpfilter.Name) {
+		return nil
+	}
+
+	return r.chain.LogPoller().RegisterFilter(ctx, lpfilter)
+}
+
+func (r *Relayer) UnregisterLogTracking(ctx context.Context, filterName string) error {
+	if filterName == "" {
+		return errEmptyFilterName
+	}
+	if !r.chain.LogPoller().HasFilter(filterName) {
+		return nil
+	}
+
+	return r.chain.LogPoller().UnregisterFilter(ctx, filterName)
+}
+
+func (r *Relayer) GetTransactionStatus(ctx context.Context, transactionID commontypes.IdempotencyKey) (commontypes.TransactionStatus, error) {
+	status, err := r.chain.TxManager().GetTransactionStatus(ctx, transactionID)
+	if err != nil {
+		return commontypes.Unknown, err
+	}
+
+	return commontypes.TransactionStatus(status), nil
+}
+
+func blockFromConfidence(ctx context.Context, ht heads.Tracker, confidence primitives.ConfidenceLevel) (*big.Int, error) {
+	latest, finalized, err := ht.LatestAndFinalizedBlock(ctx)
+	if err != nil {
+		return nil, err
+	}
+	if confidence == primitives.Finalized {
+		return big.NewInt(finalized.BlockNumber()), nil
+	}
+
+	return big.NewInt(latest.BlockNumber()), nil
+}
+
+func convertHead[H chains.Head[BLOCK_HASH], BLOCK_HASH chains.Hashable](h H) evmtypes.Head {
+	return evmtypes.Head{
+		Timestamp:  uint64(h.GetTimestamp().Unix()),
+		Hash:       bytesToHash(h.BlockHash().Bytes()),
+		Number:     big.NewInt(h.BlockNumber()),
+		ParentHash: bytesToHash(h.GetParentHash().Bytes()),
+	}
+}
+
+func convertReceipt(r *gethtypes.Receipt) *evmtypes.Receipt {
+	return &evmtypes.Receipt{
+		Status:            r.Status,
+		Logs:              convertLogs(r.Logs),
+		TxHash:            r.TxHash,
+		ContractAddress:   r.ContractAddress,
+		GasUsed:           r.GasUsed,
+		BlockHash:         r.BlockHash,
+		BlockNumber:       r.BlockNumber,
+		TransactionIndex:  uint64(r.TransactionIndex),
+		EffectiveGasPrice: r.EffectiveGasPrice,
+	}
+}
+
+func convertEthFilter(q evmtypes.FilterQuery) ethereum.FilterQuery {
+	return ethereum.FilterQuery{
+		FromBlock: q.FromBlock,
+		ToBlock:   q.ToBlock,
+		Addresses: arraysToAddresses(q.Addresses),
+		Topics:    arraysToHashMatrix(q.Topics),
+	}
+}
+
+var errEmptyFilterName = errors.New("filter name can't be empty")
+
+func convertLPFilter(q evmtypes.LPFilterQuery) (logpoller.Filter, error) {
+	if q.Name == "" {
+		return logpoller.Filter{}, errEmptyFilterName
+	}
+	return logpoller.Filter{
+		Name:         q.Name,
+		Addresses:    arraysToAddresses(q.Addresses),
+		EventSigs:    arraysToHashes(q.EventSigs),
+		Topic2:       arraysToHashes(q.Topic2),
+		Topic3:       arraysToHashes(q.Topic3),
+		Topic4:       arraysToHashes(q.Topic4),
+		Retention:    q.Retention,
+		MaxLogsKept:  q.MaxLogsKept,
+		LogsPerBlock: q.LogsPerBlock,
+	}, nil
+}
+
+func convertTransaction(tx *gethtypes.Transaction) *evmtypes.Transaction {
+	var to evm.Address
+	if tx.To() != nil {
+		to = *tx.To()
+	}
+
+	return &evmtypes.Transaction{
+		To:       to,
+		Data:     tx.Data(),
+		Hash:     tx.Hash(),
+		Nonce:    tx.Nonce(),
+		Gas:      tx.Gas(),
+		GasPrice: tx.GasPrice(),
+		Value:    tx.Value(),
+	}
+}
+
+func arraysToHashMatrix(input [][][32]byte) [][]common.Hash {
+	result := make([][]common.Hash, 0, len(input))
+	for _, row := range input {
+		result = append(result, arraysToHashes(row))
+	}
+	return result
+}
+
+func arraysToAddresses(input [][20]byte) []common.Address {
+	res := make([]common.Address, 0, len(input))
+	for _, s := range input {
+		res = append(res, s)
+	}
+
+	return res
+}
+
+func arraysToHashes(input [][32]byte) []common.Hash {
+	res := make([]common.Hash, 0, len(input))
+	for _, s := range input {
+		res = append(res, s)
+	}
+
+	return res
+}
+
+func hashesToArrays(input []common.Hash) [][32]byte {
+	res := make([][32]byte, 0, len(input))
+	for _, s := range input {
+		res = append(res, s)
+	}
+
+	return res
+}
+
+var empty common.Address
+
+func toEthMsg(msg *evmtypes.CallMsg) ethereum.CallMsg {
+	var to *common.Address
+
+	if empty.Cmp(msg.To) != 0 {
+		to = new(common.Address)
+		*to = msg.To
+	}
+
+	return ethereum.CallMsg{
+		From: msg.From,
+		To:   to,
+		Data: msg.Data,
+	}
+}
+
+func convertLogs(logs []*gethtypes.Log) []*evmtypes.Log {
+	ret := make([]*evmtypes.Log, 0, len(logs))
+
+	for _, l := range logs {
+		ret = append(ret, convertLog(l))
+	}
+
+	return ret
+}
+
+func convertLPLogs(logs []logpoller.Log) []*evmtypes.Log {
+	ret := make([]*evmtypes.Log, 0, len(logs))
+	for _, l := range logs {
+		gl := l.ToGethLog()
+		ret = append(ret, convertLog(&gl))
+	}
+
+	return ret
+}
+
+func convertLog(log *gethtypes.Log) *evmtypes.Log {
+	topics := hashesToArrays(log.Topics)
+
+	var eventSig [32]byte
+	if len(log.Topics) > 0 {
+		eventSig = log.Topics[0]
+	}
+
+	return &evmtypes.Log{
+		LogIndex:    uint32(log.Index),
+		BlockHash:   log.BlockHash,
+		BlockNumber: new(big.Int).SetUint64(log.BlockNumber),
+		Topics:      topics,
+		EventSig:    eventSig,
+		Address:     log.Address,
+		TxHash:      log.TxHash,
+		Data:        log.Data,
+		Removed:     log.Removed,
+	}
+}
+
+func confidenceToConformations(conf primitives.ConfidenceLevel) types.Confirmations {
+	if conf == primitives.Finalized {
+		return types.Finalized
+	}
+
+	return types.Unconfirmed
+}
+
+func bytesToHash(b []byte) (h evm.Hash) {
+	copy(h[:], b)
+	return
+}