feat: Adds an EVM RPC Provider (#186)

This adds a simple EVM RPC provider that can be used to interact with
Ethereum-like chains. It supports loading a private key from raw, with
KMS integration planned for the future.

Author: jkongie

.changeset/shy-emus-create.md

@@ -0,0 +1,5 @@
+---
+"chainlink-deployments-framework": minor
+---
+
+Adds an EVM RPC Chain Provider

chain/evm/evm_chain.go

@@ -13,6 +13,10 @@ import (
 	chain_common "github.com/smartcontractkit/chainlink-deployments-framework/chain/internal/common"
 )
 
+// ConfirmFunc is a function that takes a transaction, waits for the transaction to be confirmed,
+// and returns the block number and an error.
+type ConfirmFunc func(tx *types.Transaction) (uint64, error)
+
 // OnchainClient is an EVM chain client.
 // For EVM specifically we can use existing geth interface to abstract chain clients.
 type OnchainClient interface {
@@ -30,7 +34,7 @@ type Chain struct {
 	Client OnchainClient
 	// Note the Sign function can be abstract supporting a variety of key storage mechanisms (e.g. KMS etc).
 	DeployerKey *bind.TransactOpts
-	Confirm     func(tx *types.Transaction) (uint64, error)
+	Confirm     ConfirmFunc
 	// Users are a set of keys that can be used to interact with the chain.
 	// These are distinct from the deployer key.
 	Users []*bind.TransactOpts

chain/evm/provider/confirm_functor.go

@@ -0,0 +1,159 @@
+package provider
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"time"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+
+	chain_selectors "github.com/smartcontractkit/chain-selectors"
+
+	"github.com/smartcontractkit/chainlink-deployments-framework/chain/evm"
+	"github.com/smartcontractkit/chainlink-deployments-framework/deployment"
+)
+
+// ConfirmFunctor is an interface for creating a confirmation function for transactions on the
+// EVM chain.
+type ConfirmFunctor interface {
+	// Generate returns a function that confirms transactions on the EVM chain.
+	Generate(
+		ctx context.Context, selector uint64, client evm.OnchainClient, from common.Address,
+	) (evm.ConfirmFunc, error)
+}
+
+// ConfirmFuncGeth returns a ConfirmFunctor that uses the Geth client to confirm transactions.
+func ConfirmFuncGeth(waitMinedTimeout time.Duration) ConfirmFunctor {
+	return &confirmFuncGeth{
+		waitMinedTimeout: waitMinedTimeout,
+	}
+}
+
+// confirmFuncGeth implements the ConfirmFunctor interface which generates a confirmation function
+// for transactions using the Geth client.
+type confirmFuncGeth struct {
+	waitMinedTimeout time.Duration
+}
+
+// Generate returns a function that confirms transactions using the Geth client.
+func (g *confirmFuncGeth) Generate(
+	ctx context.Context, selector uint64, client evm.OnchainClient, from common.Address,
+) (evm.ConfirmFunc, error) {
+	return func(tx *types.Transaction) (uint64, error) {
+		var blockNum uint64
+		if tx == nil {
+			return 0, fmt.Errorf("tx was nil, nothing to confirm for selector: %d", selector)
+		}
+
+		ctxTimeout, cancel := context.WithTimeout(ctx, g.waitMinedTimeout)
+		defer cancel()
+
+		receipt, err := bind.WaitMined(ctxTimeout, client, tx)
+		if err != nil {
+			return 0, fmt.Errorf("tx %s failed to confirm for selector %d: %w",
+				tx.Hash().Hex(), selector, err,
+			)
+		}
+		if receipt == nil {
+			return blockNum, fmt.Errorf("receipt was nil for tx %s for selector %d",
+				tx.Hash().Hex(), selector,
+			)
+		}
+
+		blockNum = receipt.BlockNumber.Uint64()
+
+		if receipt.Status == 0 {
+			reason, err := getErrorReasonFromTx(ctxTimeout, client, from, tx, receipt)
+			if err == nil && reason != "" {
+				return 0, fmt.Errorf("tx %s reverted for selector %d: %s",
+					tx.Hash().Hex(), selector, reason,
+				)
+			}
+
+			return blockNum, fmt.Errorf("tx %s reverted, could not decode error reason for selector %d",
+				tx.Hash().Hex(), selector,
+			)
+		}
+
+		return blockNum, nil
+	}, nil
+}
+
+// ConfirmFuncSeth returns a ConfirmFunctor that uses the Seth client to confirm transactions.
+// It requires the RPC URL, a list of directories where Geth wrappers are located, and an optional
+// configuration file path for the Seth client. If you do not have a configuration file, you can
+// pass an empty string.
+func ConfirmFuncSeth(
+	rpcURL string, waitMinedTimeout time.Duration, gethWrapperDirs []string, configFilePath string,
+) ConfirmFunctor {
+	return &confirmFuncSeth{
+		rpcURL:           rpcURL,
+		waitMinedTimeout: waitMinedTimeout,
+		gethWrappersDirs: gethWrapperDirs,
+		configFilePath:   configFilePath,
+	}
+}
+
+// confirmFuncSeth implements the ConfirmFunctor interface which generates a confirmation function
+// for transactions using the Seth client.
+type confirmFuncSeth struct {
+	rpcURL           string
+	waitMinedTimeout time.Duration
+	gethWrappersDirs []string
+	configFilePath   string
+}
+
+// Generate returns a function that confirms transactions using the Seth client. The provided
+// client must be a MultiClient.
+func (g *confirmFuncSeth) Generate(
+	ctx context.Context, selector uint64, client evm.OnchainClient, from common.Address,
+) (evm.ConfirmFunc, error) {
+	// Convert the client to a MultiClient because we need to use the multi-client's WaitMined
+	// method.
+	multiClient, ok := client.(*deployment.MultiClient)
+	if !ok {
+		return nil, fmt.Errorf("expected client to be of type *deployment.MultiClient, got %T", client)
+	}
+
+	// Get the ChainID from the selector
+	chainIDStr, err := chain_selectors.GetChainIDFromSelector(selector)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get chain ID from selector %d: %w", selector, err)
+	}
+
+	chainID, err := strconv.ParseUint(chainIDStr, 10, 64)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse chain ID %s: %w", chainIDStr, err)
+	}
+
+	// Setup the seth client
+	sethClient, err := newSethClient(
+		g.rpcURL, chainID, g.gethWrappersDirs, g.configFilePath,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to setup seth client: %w", err)
+	}
+
+	return func(tx *types.Transaction) (uint64, error) {
+		ctxTimeout, cancel := context.WithTimeout(ctx, g.waitMinedTimeout)
+		defer cancel()
+
+		if _, err := multiClient.WaitMined(ctxTimeout, tx); err != nil {
+			return 0, err
+		}
+
+		decoded, err := sethClient.DecodeTx(tx)
+		if err != nil {
+			return 0, err
+		}
+
+		if decoded.Receipt == nil {
+			return 0, fmt.Errorf("no receipt found for transaction %s even though it wasn't reverted. This should not happen", tx.Hash().String())
+		}
+
+		return decoded.Receipt.BlockNumber.Uint64(), nil
+	}, nil
+}