fix(mcms): select public rpc for fork tests (#553)

### What

Ignore CLL rpcs when selecting the RPC for the ForkedEnvironment (used
by anvil to fetch
the contract state).

### Why

In the CI, the fork tests need to GAP to access the CLL rpcs. However,
because we run anvil inside a containers, the setup gets rather
complicated -- we need to copy+adapt the entries added to `/etc/hosts`
and add GAP's custom CA certificates. But, because anvil is managed
using testcontainers (indirectly, via CTF), we'd need to add support for
this feature to CTF, then CLDF and finally the CLD workflows.

However, CLL is moving towards replacing GAP with Tailscale to access
internal resources from GHA runners. So, rather than spending
significant resources implementing the GAP solution, we're adding this
quick fix -- which should solve the problem for 95% of the proposals --
until the Tailscale option is ready.

---
DPT-277

Author: gustavogama-cll

.changeset/fine-cups-battle.md

@@ -0,0 +1,5 @@
+---
+"chainlink-deployments-framework": patch
+---
+
+fix(mcms): select public rpc for fork tests

engine/cld/environment/anvil.go

@@ -8,6 +8,7 @@ import (
 	"math/big"
 	"math/rand/v2"
 	"os"
+	"regexp"
 	"slices"
 	"strconv"
 	"sync"
@@ -30,9 +31,7 @@ import (
 	cfgnet "github.com/smartcontractkit/chainlink-deployments-framework/engine/cld/config/network"
 )
 
-var (
-	oneEth = big.NewInt(0).Exp(big.NewInt(10), big.NewInt(18), nil)
-)
+var oneEth = big.NewInt(0).Exp(big.NewInt(10), big.NewInt(18), nil)
 
 // anvilClient operates the methods exposed by the Anvil node related to forking.
 // For more information, see https://book.getfoundry.sh/reference/anvil/#custom-methods.
@@ -203,9 +202,8 @@ func newAnvilChains(
 			}
 			network.Metadata = cfgnet.EVMMetadata{
 				AnvilConfig: &cfgnet.AnvilConfig{
-					Image:          "f4hrenh9it/foundry:latest",
-					Port:           uint64(ports[0]), //nolint:gosec // G115: int to uint64 conversion is safe here (port numbers are always in valid range)
-					ArchiveHTTPURL: network.RPCs[0].HTTPURL,
+					Image: "f4hrenh9it/foundry:latest",
+					Port:  uint64(ports[0]), //nolint:gosec // G115: int to uint64 conversion is safe here (port numbers are always in valid range)
 				},
 			}
 		}
@@ -222,6 +220,11 @@ func newAnvilChains(
 			continue
 		}
 
+		if err := selectPublicRPC(lggr, &metadata, network.ChainSelector, network.RPCs); err != nil {
+			lggr.Infof("Excluding chain with ID %d from environment: %s", chainID, err.Error())
+			continue
+		}
+
 		// Skip chains that are not included in the address book
 		if _, ok := addressesByChain[chainSelector]; !ok {
 			lggr.Infof("Excluding chain with selector %d from environment, does not have addresses defined in the address book", chainSelector)
@@ -301,3 +304,28 @@ func newAnvilChains(
 		ChainConfigs: chainConfigsBySelector,
 	}, nil
 }
+
+func selectPublicRPC(
+	lggr logger.Logger, metadata *cfgnet.EVMMetadata, chainSelector uint64, rpcs []cfgnet.RPC,
+) error {
+	if isPublicRPC(metadata.AnvilConfig.ArchiveHTTPURL) {
+		return nil
+	}
+
+	for _, rpc := range rpcs {
+		if isPublicRPC(rpc.HTTPURL) {
+			metadata.AnvilConfig.ArchiveHTTPURL = rpc.HTTPURL
+			lggr.Infow("selected rpc for fork environment", "url", rpc.HTTPURL, "chainSelector", chainSelector)
+
+			return nil
+		}
+	}
+
+	return fmt.Errorf("no public RPCs found for chain %d", chainSelector)
+}
+
+var privateRpcRegexp = regexp.MustCompile(`^https?://(rpcs|gap\-.*\.(prod|stage))\.cldev\.sh/`)
+
+func isPublicRPC(url string) bool {
+	return !privateRpcRegexp.MatchString(url)
+}

engine/cld/environment/anvil_test.go

@@ -11,6 +11,9 @@ import (
 	"github.com/go-resty/resty/v2"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+
+	cfgnet "github.com/smartcontractkit/chainlink-deployments-framework/engine/cld/config/network"
+	"github.com/smartcontractkit/chainlink-deployments-framework/pkg/logger"
 )
 
 // JSONRPCRequest represents a JSON-RPC request
@@ -126,3 +129,102 @@ func Test_AnvilClient_SendTransaction(t *testing.T) {
 		})
 	}
 }
+
+func Test_isPublicRPC(t *testing.T) {
+	t.Parallel()
+	tests := []struct {
+		url  string
+		want bool
+	}{
+		{"http://rpcs.cldev.sh/", false},
+		{"https://rpcs.cldev.sh/", false},
+		{"https://rpcs.cldev.sh/anything", false},
+		{"https://gap-rpcs.stage.cldev.sh/anything", false},
+		{"https://gap-rpcs.prod.cldev.sh/anything", false},
+		{"https://gap-other.prod.cldev.sh/anything", false},
+		{"https://gap-other.stage.cldev.sh/anything", false},
+		{"https://gap-other.stage.cldev.sh/anything", false},
+		{"https://gap-grpc-job-distributor.public.main.prod.cldev.sh/", false},
+		{"https://gap-ws-job-distributor.public.main.prod.cldev.sh/", false},
+		{"https://gap-rpc-proxy.public.main.prod.cldev.sh/", false},
+		{"https://gap-grpc-job-distributor.public.main.stage.cldev.sh/", false},
+		{"https://gap-ws-job-distributor.public.main.stage.cldev.sh/", false},
+		{"https://gap-grpc-chainlink-catalog.public.main.stage.cldev.sh/", false},
+		{"", true},
+		{"http://", true},
+		{"https://", true},
+		{"https://rpcs.cldev.sh", true},
+		{"https://rpcs.prod.cldev.sh/anything", true},
+		{"https://rpcs.stage.cldev.sh/anything", true},
+		{"https://gap.stage.cldev.sh/anything", true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.url, func(t *testing.T) {
+			t.Parallel()
+			require.Equal(t, tt.want, isPublicRPC(tt.url))
+		})
+	}
+}
+
+func Test_selectPublicRPC(t *testing.T) {
+	t.Parallel()
+
+	lggr := logger.Test(t)
+	tests := []struct {
+		name          string
+		metadata      *cfgnet.EVMMetadata
+		chainSelector uint64
+		rpcs          []cfgnet.RPC
+		want          *cfgnet.EVMMetadata
+		wantErr       string
+	}{
+		{
+			name: "success: metadata has url",
+			metadata: &cfgnet.EVMMetadata{AnvilConfig: &cfgnet.AnvilConfig{
+				ArchiveHTTPURL: "http://metadata.url",
+			}},
+			rpcs: []cfgnet.RPC{
+				{HTTPURL: "http://other.url"},
+			},
+			want: &cfgnet.EVMMetadata{AnvilConfig: &cfgnet.AnvilConfig{
+				ArchiveHTTPURL: "http://metadata.url",
+			}},
+		},
+		{
+			name: "success: private rpc in metadata is replaced public url from parameters",
+			metadata: &cfgnet.EVMMetadata{AnvilConfig: &cfgnet.AnvilConfig{
+				ArchiveHTTPURL: "http://gap-rpc.prod.cldev.sh/ethereum/sepolia",
+			}},
+			rpcs: []cfgnet.RPC{
+				{HTTPURL: "http://rpcs.cldev.sh/ethereum/sepolia"},
+				{HTTPURL: "http://public.rpc.url"},
+			},
+			want: &cfgnet.EVMMetadata{AnvilConfig: &cfgnet.AnvilConfig{
+				ArchiveHTTPURL: "http://public.rpc.url",
+			}},
+		},
+		{
+			name: "failure: no public rpcs found",
+			metadata: &cfgnet.EVMMetadata{AnvilConfig: &cfgnet.AnvilConfig{
+				ArchiveHTTPURL: "http://gap-rpc.prod.cldev.sh/ethereum/sepolia",
+			}},
+			rpcs: []cfgnet.RPC{
+				{HTTPURL: "http://rpcs.cldev.sh/ethereum/sepolia"},
+			},
+			wantErr: "no public RPCs found for chain 0",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			err := selectPublicRPC(lggr, tt.metadata, tt.chainSelector, tt.rpcs)
+			if tt.wantErr == "" {
+				require.NoError(t, err)
+				require.Equal(t, tt.want, tt.metadata)
+			} else {
+				require.ErrorContains(t, err, tt.wantErr)
+			}
+		})
+	}
+}

engine/cld/legacy/cli/mcmsv2/mcms_v2.go

@@ -620,6 +620,10 @@ func buildExecuteForkCommand(lggr logger.Logger, domain cldf_domain.Domain, prop
 				return fmt.Errorf("error creating config: %w", err)
 			}
 
+			if len(cfg.forkedEnv.ChainConfigs[cfg.chainSelector].HTTPRPCs) == 0 {
+				return fmt.Errorf("no rpcs loaded in forked environment for chain %d (fork tests require public RPCs)", cfg.chainSelector)
+			}
+
 			// get the chain URL, chain ID and MCM contract address
 			url := cfg.forkedEnv.ChainConfigs[cfg.chainSelector].HTTPRPCs[0].External
 			anvilClient := rpc.New(url, nil)