feat: migrate onchain client

copy multiclient and rpc_config from chainlink repo to here.

JIRA: https://smartcontract-it.atlassian.net/browse/CLD-130

Author: graham-chainlink

deployment/labels.go deployment/address_book_labels.godeployment/labels.go renamed to deployment/address_book_labels.go

@@ -0,0 +1,32 @@
+package deployment
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/rpc"
+)
+
+// OnchainClient is an EVM chain client.
+// For EVM specifically we can use existing geth interface
+// to abstract chain clients.
+type OnchainClient interface {
+	bind.ContractBackend
+	bind.DeployBackend
+	BalanceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (*big.Int, error)
+	NonceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (uint64, error)
+}
+
+func MaybeDataErr(err error) error {
+	//revive:disable
+	var d rpc.DataError
+	ok := errors.As(err, &d)
+	if ok {
+		return fmt.Errorf("%s: %v", d.Error(), d.ErrorData())
+	}
+	return err
+}

deployment/labels_test.go deployment/address_book_labels_test.godeployment/labels_test.go renamed to deployment/address_book_labels_test.go

@@ -0,0 +1,234 @@
+package deployment
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"math/big"
+	"time"
+
+	"github.com/avast/retry-go/v4"
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
+
+	"github.com/smartcontractkit/chainlink-common/pkg/logger"
+
+	chainsel "github.com/smartcontractkit/chain-selectors"
+)
+
+const (
+	// Default retry configuration for RPC calls
+	RPCDefaultRetryAttempts = 10
+	RPCDefaultRetryDelay    = 1000 * time.Millisecond
+
+	// Default retry configuration for dialing RPC endpoints
+	RPCDefaultDialRetryAttempts = 10
+	RPCDefaultDialRetryDelay    = 1000 * time.Millisecond
+)
+
+type RetryConfig struct {
+	Attempts uint
+	Delay    time.Duration
+}
+
+func defaultRetryConfig() RetryConfig {
+	return RetryConfig{
+		Attempts: RPCDefaultRetryAttempts,
+		Delay:    RPCDefaultRetryDelay,
+	}
+}
+
+// MultiClient should comply with the OnchainClient interface
+var _ OnchainClient = &MultiClient{}
+
+type MultiClient struct {
+	*ethclient.Client
+	Backups     []*ethclient.Client
+	RetryConfig RetryConfig
+	lggr        logger.Logger
+	chainName   string
+}
+
+func NewMultiClient(lggr logger.Logger, rpcsCfg RPCConfig, opts ...func(client *MultiClient)) (*MultiClient, error) {
+	if len(rpcsCfg.RPCs) == 0 {
+		return nil, errors.New("no RPCs provided, need at least one")
+	}
+	// Set the chain name
+	chain, exists := chainsel.ChainBySelector(rpcsCfg.ChainSelector)
+	if !exists {
+		return nil, fmt.Errorf("chain with selector %d not found", rpcsCfg.ChainSelector)
+	}
+	mc := MultiClient{lggr: lggr, chainName: chain.Name}
+
+	clients := make([]*ethclient.Client, 0, len(rpcsCfg.RPCs))
+	for i, rpc := range rpcsCfg.RPCs {
+		client, err := mc.dialWithRetry(rpc, lggr)
+		if err != nil {
+			lggr.Warnf("failed to dial client %d for RPC '%s' trying with the next one: %v", i, rpc.Name, err)
+			continue
+		}
+		clients = append(clients, client)
+	}
+
+	if len(clients) == 0 {
+		return nil, errors.New("no valid RPC clients created")
+	}
+
+	mc.Client = clients[0]
+	mc.Backups = clients[1:]
+	mc.RetryConfig = defaultRetryConfig()
+
+	for _, opt := range opts {
+		opt(&mc)
+	}
+	return &mc, nil
+}
+
+func (mc *MultiClient) SendTransaction(ctx context.Context, tx *types.Transaction) error {
+	return mc.retryWithBackups("SendTransaction", func(client *ethclient.Client) error {
+		return client.SendTransaction(ctx, tx)
+	})
+}
+
+func (mc *MultiClient) CallContract(ctx context.Context, msg ethereum.CallMsg, blockNumber *big.Int) ([]byte, error) {
+	var result []byte
+	err := mc.retryWithBackups("CallContract", func(client *ethclient.Client) error {
+		var err error
+		result, err = client.CallContract(ctx, msg, blockNumber)
+		return err
+	})
+	return result, err
+}
+
+func (mc *MultiClient) CallContractAtHash(ctx context.Context, msg ethereum.CallMsg, blockHash common.Hash) ([]byte, error) {
+	var result []byte
+	err := mc.retryWithBackups("CallContractAtHash", func(client *ethclient.Client) error {
+		var err error
+		result, err = client.CallContractAtHash(ctx, msg, blockHash)
+		return err
+	})
+	return result, err
+}
+
+func (mc *MultiClient) CodeAt(ctx context.Context, account common.Address, blockNumber *big.Int) ([]byte, error) {
+	var code []byte
+	err := mc.retryWithBackups("CodeAt", func(client *ethclient.Client) error {
+		var err error
+		code, err = client.CodeAt(ctx, account, blockNumber)
+		return err
+	})
+	return code, err
+}
+
+func (mc *MultiClient) CodeAtHash(ctx context.Context, account common.Address, blockHash common.Hash) ([]byte, error) {
+	var code []byte
+	err := mc.retryWithBackups("CodeAtHash", func(client *ethclient.Client) error {
+		var err error
+		code, err = client.CodeAtHash(ctx, account, blockHash)
+		return err
+	})
+	return code, err
+}
+
+func (mc *MultiClient) NonceAt(ctx context.Context, account common.Address, block *big.Int) (uint64, error) {
+	var count uint64
+	err := mc.retryWithBackups("NonceAt", func(client *ethclient.Client) error {
+		var err error
+		count, err = client.NonceAt(ctx, account, block)
+		return err
+	})
+	return count, err
+}
+
+func (mc *MultiClient) NonceAtHash(ctx context.Context, account common.Address, blockHash common.Hash) (uint64, error) {
+	var count uint64
+	err := mc.retryWithBackups("NonceAtHash", func(client *ethclient.Client) error {
+		var err error
+		count, err = client.NonceAtHash(ctx, account, blockHash)
+		return err
+	})
+	return count, err
+}
+
+func (mc *MultiClient) WaitMined(ctx context.Context, tx *types.Transaction) (*types.Receipt, error) {
+	mc.lggr.Debugf("Waiting for tx %s to be mined for chain %s", tx.Hash().Hex(), mc.chainName)
+	// no retries here because we want to wait for the tx to be mined
+	resultCh := make(chan *types.Receipt)
+	doneCh := make(chan struct{})
+
+	waitMined := func(client *ethclient.Client, tx *types.Transaction) {
+		mc.lggr.Debugf("Waiting for tx %s to be mined with chain %s", tx.Hash().Hex(), mc.chainName)
+		receipt, err := bind.WaitMined(ctx, client, tx)
+		if err != nil {
+			mc.lggr.Warnf("WaitMined error %v with chain %s", err, mc.chainName)
+			return
+		}
+		select {
+		case resultCh <- receipt:
+		case <-doneCh:
+			return
+		}
+	}
+
+	for _, client := range append([]*ethclient.Client{mc.Client}, mc.Backups...) {
+		go waitMined(client, tx)
+	}
+	var receipt *types.Receipt
+	select {
+	case receipt = <-resultCh:
+		close(doneCh)
+		mc.lggr.Debugf("Tx %s mined with chain %s", tx.Hash().Hex(), mc.chainName)
+		return receipt, nil
+	case <-ctx.Done():
+		mc.lggr.Warnf("WaitMined context done %v", ctx.Err())
+		close(doneCh)
+		return nil, ctx.Err()
+	}
+}
+
+func (mc *MultiClient) retryWithBackups(opName string, op func(*ethclient.Client) error) error {
+	var err error
+	for i, client := range append([]*ethclient.Client{mc.Client}, mc.Backups...) {
+		err2 := retry.Do(func() error {
+			mc.lggr.Debugf("Trying op %s with chain %s client index %d", opName, mc.chainName, i)
+			err = op(client)
+			if err != nil {
+				mc.lggr.Warnf("retryable error '%s' for op %s with chain %s client index %d", MaybeDataErr(err), opName, mc.chainName, i)
+				return err
+			}
+			return nil
+		}, retry.Attempts(mc.RetryConfig.Attempts), retry.Delay(mc.RetryConfig.Delay))
+		if err2 == nil {
+			return nil
+		}
+		mc.lggr.Infof("Client at index %d failed, trying next client chain %s", i, mc.chainName)
+	}
+	return errors.Join(err, fmt.Errorf("all backup clients %v failed for chain %s", mc.Backups, mc.chainName))
+}
+
+func (mc *MultiClient) dialWithRetry(rpc RPC, lggr logger.Logger) (*ethclient.Client, error) {
+	endpoint, err := rpc.ToEndpoint()
+	if err != nil {
+		return nil, err
+	}
+
+	var client *ethclient.Client
+	err = retry.Do(func() error {
+		var err2 error
+		mc.lggr.Debugf("dialing endpoint '%s' for RPC %s for chain %s", endpoint, rpc.Name, mc.chainName)
+		client, err2 = ethclient.Dial(endpoint)
+		if err2 != nil {
+			lggr.Warnf("retryable error for RPC %s:%s for chain %s  %v", rpc.Name, endpoint, mc.chainName, err2)
+			return err2
+		}
+		return nil
+	}, retry.Attempts(RPCDefaultDialRetryAttempts), retry.Delay(RPCDefaultDialRetryDelay))
+
+	if err != nil {
+		return nil, errors.Join(err, fmt.Errorf("failed to dial endpoint '%s' for RPC %s for chain %s after retries", endpoint, rpc.Name, mc.chainName))
+	}
+	return client, nil
+}

deployment/environment.go

@@ -0,0 +1,44 @@
+package deployment
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/smartcontractkit/chainlink-common/pkg/logger"
+)
+
+// TODO(giogam): This test is incomplete, it should be completed with support for websockets URLS
+func TestMultiClient(t *testing.T) {
+	var (
+		lggr                 = logger.Test(t)
+		chainSelector uint64 = 16015286601757825753 // "ethereum-testnet-sepolia"
+		wsURL                = "ws://example.com"
+		httpURL              = "http://example.com"
+	)
+
+	// Expect defaults to be set if not provided.
+	mc, err := NewMultiClient(lggr, RPCConfig{ChainSelector: chainSelector, RPCs: []RPC{
+		{Name: "test-rpc", WSURL: wsURL, HTTPURL: httpURL, PreferredURLScheme: URLSchemePreferenceHTTP},
+	}})
+
+	require.NoError(t, err)
+	require.NotNil(t, mc)
+
+	assert.Equal(t, "ethereum-testnet-sepolia", mc.chainName)
+	assert.Equal(t, mc.RetryConfig.Attempts, uint(RPCDefaultRetryAttempts))
+	assert.Equal(t, RPCDefaultRetryDelay, mc.RetryConfig.Delay)
+
+	// Expect error if no RPCs provided.
+	_, err = NewMultiClient(lggr, RPCConfig{ChainSelector: chainSelector, RPCs: []RPC{}})
+	require.Error(t, err)
+
+	// Expect second client to be set as backup.
+	mc, err = NewMultiClient(lggr, RPCConfig{ChainSelector: chainSelector, RPCs: []RPC{
+		{Name: "test-rpc", WSURL: wsURL, HTTPURL: httpURL, PreferredURLScheme: URLSchemePreferenceHTTP},
+		{Name: "test-rpc", WSURL: wsURL, HTTPURL: httpURL, PreferredURLScheme: URLSchemePreferenceHTTP},
+	}})
+	require.NoError(t, err)
+	require.Len(t, mc.Backups, 1)
+}

deployment/multiclient.go

@@ -0,0 +1,67 @@
+package deployment
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+)
+
+type URLSchemePreference int
+
+const (
+	URLSchemePreferenceNone URLSchemePreference = iota
+	URLSchemePreferenceWS
+	URLSchemePreferenceHTTP
+)
+
+func URLSchemePreferenceFromString(s string) (URLSchemePreference, error) {
+	switch strings.ToLower(s) {
+	case "none":
+		return URLSchemePreferenceNone, nil
+	case "ws":
+		return URLSchemePreferenceWS, nil
+	case "http":
+		return URLSchemePreferenceHTTP, nil
+	default:
+		return URLSchemePreferenceNone, fmt.Errorf("invalid URLSchemePreference: %s", s)
+	}
+}
+
+func (u *URLSchemePreference) UnmarshalText(text []byte) error {
+	preference, err := URLSchemePreferenceFromString(string(text))
+	if err != nil {
+		return err
+	}
+	*u = preference
+
+	return nil
+}
+
+type RPC struct {
+	Name               string
+	WSURL              string
+	HTTPURL            string
+	PreferredURLScheme URLSchemePreference
+}
+
+// ToEndpoint returns the correct endpoint based on the preferred URL scheme
+// If the preferred URL scheme is not set, it will return the WS URL
+// If the preferred URL scheme is set to WS, it will return the WS URL
+// If the preferred URL scheme is set to HTTP, it will return the HTTP URL
+func (r RPC) ToEndpoint() (string, error) {
+	switch r.PreferredURLScheme {
+	case URLSchemePreferenceNone, URLSchemePreferenceWS:
+		return r.WSURL, nil
+	case URLSchemePreferenceHTTP:
+		return r.HTTPURL, nil
+	default:
+		return "", errors.New("unknown URLSchemePreference")
+	}
+}
+
+// RPCConfig is a configuration for a chain.
+// It contains a chain selector and a list of RPCs
+type RPCConfig struct {
+	ChainSelector uint64
+	RPCs          []RPC
+}