feat: route state-backed requests to archive nodes

configs/config.sample.yml

@@ -33,20 +33,24 @@ upstreams:
   #     it quickly updates the gateway with the latest block height. If this
   #     setting is undefined, the gateway will attempt to subscribe to new
   #     heads if the upstream supports it.
+  # nodeType - full or archive
   - id: my-node
     httpURL: "http://12.57.207.168:8545"
     wsURL: "wss://12.57.207.168:8546"
     group: primary
+    nodeType: full
   - id: infura-eth
     httpURL: "https://mainnet.infura.io/v3/${INFURA_API_KEY}"
     wsURL: "wss://mainnet.infura.io/ws/v3/${INFURA_API_KEY}"
     basicAuth:
       username: ~
       password: ${INFURA_API_KEY_SECRET}
     group: fallback
+    nodeType: archive
   - id: alchemy-eth
     httpURL: "https://eth-mainnet.g.alchemy.com/v2/${ALCHEMY_API_KEY}"
     wsURL: "wss://eth-mainnet.g.alchemy.com/v2/${ALCHEMY_API_KEY}"
     healthCheck:
       useWsForBlockHeight: false
     group: fallback
+    nodeType: full

internal/config/config.go

@@ -8,13 +8,21 @@ import (
 	"gopkg.in/yaml.v3"
 )
 
+type NodeType string
+
+const (
+	Archive NodeType = "archive"
+	Full    NodeType = "full"
+)
+
 type UpstreamConfig struct {
 	BasicAuthConfig   BasicAuthConfig   `yaml:"basicAuth"`
 	HealthCheckConfig HealthCheckConfig `yaml:"healthCheck"`
 	ID                string            `yaml:"id"`
 	HTTPURL           string            `yaml:"httpURL"`
 	WSURL             string            `yaml:"wsURL"`
 	GroupID           string            `yaml:"group"`
+	NodeType          NodeType          `yaml:"nodeType"`
 }
 
 func (c *UpstreamConfig) isValid(groups []GroupConfig) bool {
@@ -25,6 +33,12 @@ func (c *UpstreamConfig) isValid(groups []GroupConfig) bool {
 		zap.L().Error("httpUrl cannot be empty", zap.Any("config", c), zap.String("upstreamId", c.ID))
 	}
 
+	if c.NodeType == "" {
+		isValid = false
+
+		zap.L().Error("nodeType cannot be empty", zap.Any("config", c), zap.String("upstreamId", c.ID))
+	}
+
 	if c.HealthCheckConfig.UseWSForBlockHeight != nil && *c.HealthCheckConfig.UseWSForBlockHeight && c.WSURL == "" {
 		isValid = false
 

internal/config/config_test.go

@@ -120,10 +120,12 @@ func TestParseConfig_ValidConfig(t *testing.T) {
         healthCheck:
           useWsForBlockHeight: true
         group: primary
+        nodeType: full
       - id: ankr-polygon
         httpURL: "https://rpc.ankr.com/polygon"
         wsURL: "wss://rpc.ankr.com/polygon/ws/${ANKR_API_KEY}"
         group: fallback
+        nodeType: archive
   `
 	configBytes := []byte(config)
 
@@ -142,7 +144,8 @@ func TestParseConfig_ValidConfig(t *testing.T) {
 				HealthCheckConfig: HealthCheckConfig{
 					UseWSForBlockHeight: newBool(true),
 				},
-				GroupID: "primary",
+				GroupID:  "primary",
+				NodeType: Full,
 			},
 			{
 				ID:      "ankr-polygon",
@@ -151,7 +154,8 @@ func TestParseConfig_ValidConfig(t *testing.T) {
 				HealthCheckConfig: HealthCheckConfig{
 					UseWSForBlockHeight: nil,
 				},
-				GroupID: "fallback",
+				GroupID:  "fallback",
+				NodeType: Archive,
 			},
 		},
 		Global: GlobalConfig{

internal/metadata/request_metadata.go

@@ -0,0 +1,5 @@
+package metadata
+
+type RequestMetadata struct {
+	IsStateRequired bool
+}

internal/metadata/request_metadata_parser.go

@@ -0,0 +1,21 @@
+package metadata
+
+import (
+	"github.com/satsuma-data/node-gateway/internal/jsonrpc"
+)
+
+type RequestMetadataParser struct{}
+
+func (p *RequestMetadataParser) Parse(requestBody jsonrpc.RequestBody) RequestMetadata {
+	result := RequestMetadata{}
+
+	switch requestBody.Method {
+	case "eth_getBalance", "eth_getStorageAt", "eth_getTransactionCount", "eth_getCode", "eth_call", "eth_estimateGas":
+		// List of state methods: https://ethereum.org/en/developers/docs/apis/json-rpc/#state_methods
+		result.IsStateRequired = true
+	default:
+		result.IsStateRequired = false
+	}
+
+	return result
+}

internal/metadata/request_metadata_parser_test.go

@@ -0,0 +1,42 @@
+package metadata
+
+import (
+	"testing"
+
+	"github.com/satsuma-data/node-gateway/internal/jsonrpc"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRequestMetadataParser_Parse(t *testing.T) {
+	type args struct {
+		requestBody jsonrpc.RequestBody
+	}
+
+	type testArgs struct {
+		name string
+		args args
+		want RequestMetadata
+	}
+
+	testForMethod := func(methodName string, isStateRequired bool) testArgs {
+		return testArgs{
+			methodName,
+			args{jsonrpc.RequestBody{Method: methodName}},
+			RequestMetadata{IsStateRequired: isStateRequired},
+		}
+	}
+
+	tests := []testArgs{
+		testForMethod("eth_call", true),
+		testForMethod("eth_getBalance", true),
+		testForMethod("eth_getBlockByNumber", false),
+		testForMethod("eth_getTransactionReceipt", false),
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			p := &RequestMetadataParser{}
+			assert.Equalf(t, tt.want, p.Parse(tt.args.requestBody), "Parse(%v)", tt.args.requestBody)
+		})
+	}
+}

internal/route/filtering_strategy.go

@@ -2,6 +2,7 @@ package route
 
 import (
 	"github.com/satsuma-data/node-gateway/internal/config"
+	"github.com/satsuma-data/node-gateway/internal/metadata"
 	"github.com/satsuma-data/node-gateway/internal/types"
 	"go.uber.org/zap"
 )
@@ -11,12 +12,18 @@ type FilteringRoutingStrategy struct {
 	BackingStrategy RoutingStrategy
 }
 
-func (s *FilteringRoutingStrategy) RouteNextRequest(upstreamsByPriority types.PriorityToUpstreamsMap) (string, error) {
-	filteredUpstreams := s.filter(upstreamsByPriority)
-	return s.BackingStrategy.RouteNextRequest(filteredUpstreams)
+func (s *FilteringRoutingStrategy) RouteNextRequest(
+	upstreamsByPriority types.PriorityToUpstreamsMap,
+	requestMetadata metadata.RequestMetadata,
+) (string, error) {
+	filteredUpstreams := s.filter(upstreamsByPriority, requestMetadata)
+	return s.BackingStrategy.RouteNextRequest(filteredUpstreams, requestMetadata)
 }
 
-func (s *FilteringRoutingStrategy) filter(upstreamsByPriority types.PriorityToUpstreamsMap) types.PriorityToUpstreamsMap {
+func (s *FilteringRoutingStrategy) filter(
+	upstreamsByPriority types.PriorityToUpstreamsMap,
+	requestMetadata metadata.RequestMetadata,
+) types.PriorityToUpstreamsMap {
 	priorityToHealthyUpstreams := make(types.PriorityToUpstreamsMap)
 
 	for priority, upstreamConfigs := range upstreamsByPriority {
@@ -25,7 +32,7 @@ func (s *FilteringRoutingStrategy) filter(upstreamsByPriority types.PriorityToUp
 		filteredUpstreams := make([]*config.UpstreamConfig, 0)
 
 		for _, upstreamConfig := range upstreamConfigs {
-			if s.NodeFilter.Apply(nil, upstreamConfig) {
+			if s.NodeFilter.Apply(requestMetadata, upstreamConfig) {
 				filteredUpstreams = append(filteredUpstreams, upstreamConfig)
 			}
 		}

internal/route/node_filter.go

@@ -6,17 +6,15 @@ import (
 	"github.com/satsuma-data/node-gateway/internal/metadata"
 )
 
-type RequestMetadata struct{}
-
 type NodeFilter interface {
-	Apply(requestMetadata *RequestMetadata, upstreamConfig *config.UpstreamConfig) bool
+	Apply(requestMetadata metadata.RequestMetadata, upstreamConfig *config.UpstreamConfig) bool
 }
 
 type AndFilter struct {
 	filters []NodeFilter
 }
 
-func (a *AndFilter) Apply(requestMetadata *RequestMetadata, upstreamConfig *config.UpstreamConfig) bool {
+func (a *AndFilter) Apply(requestMetadata metadata.RequestMetadata, upstreamConfig *config.UpstreamConfig) bool {
 	var result = true
 
 	for filterIndex := range a.filters {
@@ -34,7 +32,7 @@ type IsHealthy struct {
 	healthCheckManager checks.HealthCheckManager
 }
 
-func (f *IsHealthy) Apply(_ *RequestMetadata, upstreamConfig *config.UpstreamConfig) bool {
+func (f *IsHealthy) Apply(_ metadata.RequestMetadata, upstreamConfig *config.UpstreamConfig) bool {
 	var upstreamStatus = f.healthCheckManager.GetUpstreamStatus(upstreamConfig.ID)
 	return upstreamStatus.PeerCheck.IsPassing() && upstreamStatus.SyncingCheck.IsPassing()
 }
@@ -44,7 +42,7 @@ type IsAtGlobalMaxHeight struct {
 	chainMetadataStore *metadata.ChainMetadataStore
 }
 
-func (f *IsAtGlobalMaxHeight) Apply(_ *RequestMetadata, upstreamConfig *config.UpstreamConfig) bool {
+func (f *IsAtGlobalMaxHeight) Apply(_ metadata.RequestMetadata, upstreamConfig *config.UpstreamConfig) bool {
 	maxHeight := f.chainMetadataStore.GetGlobalMaxHeight()
 
 	upstreamStatus := f.healthCheckManager.GetUpstreamStatus(upstreamConfig.ID)
@@ -57,14 +55,27 @@ type IsAtMaxHeightForGroup struct {
 	chainMetadataStore *metadata.ChainMetadataStore
 }
 
-func (f *IsAtMaxHeightForGroup) Apply(_ *RequestMetadata, upstreamConfig *config.UpstreamConfig) bool {
+func (f *IsAtMaxHeightForGroup) Apply(_ metadata.RequestMetadata, upstreamConfig *config.UpstreamConfig) bool {
 	maxHeightForGroup := f.chainMetadataStore.GetMaxHeightForGroup(upstreamConfig.GroupID)
 
 	upstreamStatus := f.healthCheckManager.GetUpstreamStatus(upstreamConfig.ID)
 
 	return upstreamStatus.BlockHeightCheck.IsPassing(maxHeightForGroup)
 }
 
+type SimpleIsStatePresent struct{}
+
+func (f *SimpleIsStatePresent) Apply(
+	requestMetadata metadata.RequestMetadata,
+	upstreamConfig *config.UpstreamConfig,
+) bool {
+	if requestMetadata.IsStateRequired {
+		return upstreamConfig.NodeType == config.Archive
+	}
+
+	return true
+}
+
 func CreateNodeFilter(
 	filterNames []NodeFilterType,
 	manager checks.HealthCheckManager,
@@ -96,6 +107,8 @@ func CreateSingleNodeFilter(
 			healthCheckManager: manager,
 			chainMetadataStore: store,
 		}
+	case SimpleStatePresent:
+		return &SimpleIsStatePresent{}
 	default:
 		panic("Unknown filter type " + filterName + "!")
 	}
@@ -104,7 +117,8 @@ func CreateSingleNodeFilter(
 type NodeFilterType string
 
 const (
-	Healthy           NodeFilterType = "healthy"
-	GlobalMaxHeight   NodeFilterType = "globalMaxHeight"
-	MaxHeightForGroup NodeFilterType = "maxHeightForGroup"
+	Healthy            NodeFilterType = "healthy"
+	GlobalMaxHeight    NodeFilterType = "globalMaxHeight"
+	MaxHeightForGroup  NodeFilterType = "maxHeightForGroup"
+	SimpleStatePresent NodeFilterType = "simpleStatePresent"
 )

internal/route/node_filter_test.go

@@ -4,18 +4,19 @@ import (
 	"testing"
 
 	"github.com/satsuma-data/node-gateway/internal/config"
+	"github.com/satsuma-data/node-gateway/internal/metadata"
 	"github.com/stretchr/testify/assert"
 )
 
 type AlwaysPass struct{}
 
-func (AlwaysPass) Apply(_ *RequestMetadata, _ *config.UpstreamConfig) bool {
+func (AlwaysPass) Apply(metadata.RequestMetadata, *config.UpstreamConfig) bool {
 	return true
 }
 
 type AlwaysFail struct{}
 
-func (AlwaysFail) Apply(_ *RequestMetadata, _ *config.UpstreamConfig) bool {
+func (AlwaysFail) Apply(metadata.RequestMetadata, *config.UpstreamConfig) bool {
 	return false
 }
 
@@ -24,8 +25,8 @@ func TestAndFilter_Apply(t *testing.T) {
 		filters []NodeFilter
 	}
 
-	type args struct {
-		requestMetadata *RequestMetadata
+	type args struct { //nolint:govet // field alignment doesn't matter in tests
+		requestMetadata metadata.RequestMetadata
 		upstreamConfig  *config.UpstreamConfig
 	}
 
@@ -50,3 +51,34 @@ func TestAndFilter_Apply(t *testing.T) {
 		})
 	}
 }
+
+func TestSimpleIsStatePresentFilter_Apply(t *testing.T) {
+	fullNodeConfig := config.UpstreamConfig{NodeType: config.Full}
+	archiveNodeConfig := config.UpstreamConfig{NodeType: config.Archive}
+
+	stateMethodMetadata := metadata.RequestMetadata{IsStateRequired: true}
+	nonStateMethodMetadata := metadata.RequestMetadata{IsStateRequired: false}
+
+	type args struct { //nolint:govet // field alignment doesn't matter in tests
+		requestMetadata metadata.RequestMetadata
+		upstreamConfig  *config.UpstreamConfig
+	}
+
+	tests := []struct { //nolint:govet // field alignment doesn't matter in tests
+		name string
+		args args
+		want bool
+	}{
+		{"stateMethodFullNode", args{stateMethodMetadata, &fullNodeConfig}, false},
+		{"stateMethodArchiveNode", args{stateMethodMetadata, &archiveNodeConfig}, true},
+		{"nonStateMethodFullNode", args{nonStateMethodMetadata, &fullNodeConfig}, true},
+		{"nonStateMethodArchiveNode", args{nonStateMethodMetadata, &archiveNodeConfig}, true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			f := &SimpleIsStatePresent{}
+			assert.Equalf(t, tt.want, f.Apply(tt.args.requestMetadata, tt.args.upstreamConfig), "Apply(%v, %v)", tt.args.requestMetadata, tt.args.upstreamConfig)
+		})
+	}
+}