fix: add attribute nil verifications in chainReader

chainio/clients/elcontracts/reader.go

@@ -116,6 +116,9 @@ func (r *ChainReader) GetStakerShares(
 	ctx context.Context,
 	stakerAddress gethcommon.Address,
 ) ([]gethcommon.Address, []*big.Int, error) {
+	if r.delegationManager == nil {
+		return nil, nil, errors.New("DelegationManager contract not provided")
+	}
 	return r.delegationManager.GetDepositedShares(&bind.CallOpts{Context: ctx}, stakerAddress)
 }
 
@@ -125,6 +128,9 @@ func (r *ChainReader) GetDelegatedOperator(
 	stakerAddress gethcommon.Address,
 	blockNumber *big.Int,
 ) (gethcommon.Address, error) {
+	if r.delegationManager == nil {
+		return gethcommon.Address{}, errors.New("DelegationManager contract not provided")
+	}
 	return r.delegationManager.DelegatedTo(&bind.CallOpts{Context: ctx}, stakerAddress)
 }
 
@@ -447,6 +453,9 @@ func (r *ChainReader) GetNumOperatorSetsForOperator(
 	ctx context.Context,
 	operatorAddress gethcommon.Address,
 ) (*big.Int, error) {
+	if r.allocationManager == nil {
+		return nil, errors.New("AllocationManager contract not provided")
+	}
 	opSets, err := r.allocationManager.GetAllocatedSets(&bind.CallOpts{Context: ctx}, operatorAddress)
 	if err != nil {
 		return nil, err
@@ -460,6 +469,9 @@ func (r *ChainReader) GetOperatorSetsForOperator(
 	ctx context.Context,
 	operatorAddress gethcommon.Address,
 ) ([]allocationmanager.OperatorSet, error) {
+	if r.allocationManager == nil {
+		return nil, errors.New("AllocationManager contract not provided")
+	}
 	// TODO: we're fetching max int64 operatorSets here. What's the practical limit for timeout by RPC? do we need to
 	// paginate?
 	return r.allocationManager.GetAllocatedSets(&bind.CallOpts{Context: ctx}, operatorAddress)
@@ -473,13 +485,20 @@ func (r *ChainReader) IsOperatorRegisteredWithOperatorSet(
 ) (bool, error) {
 	if operatorSet.Id == 0 {
 		// this is an M2 AVS
+		if r.avsDirectory == nil {
+			return false, errors.New("AVSDirectory contract not provided")
+		}
+
 		status, err := r.avsDirectory.AvsOperatorStatus(&bind.CallOpts{Context: ctx}, operatorSet.Avs, operatorAddress)
 		if err != nil {
 			return false, err
 		}
 
 		return status == 1, nil
 	} else {
+		if r.allocationManager == nil {
+			return false, errors.New("AllocationManager contract not provided")
+		}
 		registeredOperatorSets, err := r.allocationManager.GetRegisteredSets(&bind.CallOpts{Context: ctx}, operatorAddress)
 		if err != nil {
 			return false, err
@@ -503,6 +522,10 @@ func (r *ChainReader) GetOperatorsForOperatorSet(
 	if operatorSet.Id == 0 {
 		return nil, errLegacyAVSsNotSupported
 	} else {
+		if r.allocationManager == nil {
+			return nil, errors.New("AllocationManager contract not provided")
+		}
+
 		return r.allocationManager.GetMembers(&bind.CallOpts{Context: ctx}, operatorSet)
 	}
 }
@@ -515,6 +538,10 @@ func (r *ChainReader) GetNumOperatorsForOperatorSet(
 	if operatorSet.Id == 0 {
 		return nil, errLegacyAVSsNotSupported
 	} else {
+		if r.allocationManager == nil {
+			return nil, errors.New("AllocationManager contract not provided")
+		}
+
 		return r.allocationManager.GetMemberCount(&bind.CallOpts{Context: ctx}, operatorSet)
 	}
 }
@@ -528,6 +555,10 @@ func (r *ChainReader) GetStrategiesForOperatorSet(
 	if operatorSet.Id == 0 {
 		return nil, errLegacyAVSsNotSupported
 	} else {
+		if r.allocationManager == nil {
+			return nil, errors.New("AllocationManager contract not provided")
+		}
+
 		return r.allocationManager.GetStrategiesInOperatorSet(&bind.CallOpts{Context: ctx}, operatorSet)
 	}
 }

chainio/clients/elcontracts/reader_test.go

@@ -130,11 +130,11 @@ func TestChainReader(t *testing.T) {
 	})
 
 	t.Run("get delegated operator", func(t *testing.T) {
-		val := big.NewInt(0)
+		blockNumber := big.NewInt(0)
 		address, err := read_clients.ElChainReader.GetDelegatedOperator(
 			ctx,
 			common.HexToAddress(operator.Address),
-			val,
+			blockNumber,
 		)
 
 		assert.NoError(t, err)
@@ -734,3 +734,182 @@ func TestAppointeesFunctions(t *testing.T) {
 		assert.NotEmpty(t, appointeesPermission)
 	})
 }
+
+func TestContractErrorCases(t *testing.T) {
+	ctx := context.Background()
+
+	testConfig := testutils.GetDefaultTestConfig()
+	anvilC, err := testutils.StartAnvilContainer(testConfig.AnvilStateFileName)
+	require.NoError(t, err)
+
+	anvilHttpEndpoint, err := anvilC.Endpoint(context.Background(), "http")
+	require.NoError(t, err)
+	contractAddrs := testutils.GetContractAddressesFromContractRegistry(anvilHttpEndpoint)
+
+	config := elcontracts.Config{
+		DelegationManagerAddress: contractAddrs.DelegationManager,
+	}
+
+	chainReader, err := testclients.NewTestChainReaderFromConfig(anvilHttpEndpoint, config)
+	require.NoError(t, err)
+
+	strategyAddr := common.HexToAddress("34634374736473673643")
+
+	t.Run("GetStrategyAndUnderlyingToken", func(t *testing.T) {
+		strategy, undToken, err := chainReader.GetStrategyAndUnderlyingToken(ctx, strategyAddr)
+		assert.Zero(t, strategy)
+		assert.Zero(t, undToken)
+		assert.Error(t, err)
+		assert.Equal(t, err.Error(), "Failed to fetch token contract: no contract code at given address")
+	})
+
+	t.Run("GetStrategyAndUnderlyingERC20Token", func(t *testing.T) {
+		strategy, methods, undToken, err := chainReader.GetStrategyAndUnderlyingERC20Token(ctx, strategyAddr)
+		assert.Zero(t, strategy)
+		assert.Zero(t, methods)
+		assert.Zero(t, undToken)
+		assert.Error(t, err)
+		assert.Equal(t, err.Error(), "Failed to fetch token contract: no contract code at given address")
+	})
+}
+
+// TestInvalidConfig tests the behavior of the chainReader when the config is invalid (e.g. missing addresses, wrong
+// addresses)
+func TestInvalidConfig(t *testing.T) {
+	testConfig := testutils.GetDefaultTestConfig()
+	anvilC, err := testutils.StartAnvilContainer(testConfig.AnvilStateFileName)
+	require.NoError(t, err)
+
+	anvilHttpEndpoint, err := anvilC.Endpoint(context.Background(), "http")
+	require.NoError(t, err)
+
+	contractAddrs := testutils.GetContractAddressesFromContractRegistry(anvilHttpEndpoint)
+
+	operatorAddr := testutils.ANVIL_FIRST_ADDRESS
+	operator := types.Operator{
+		Address: operatorAddr,
+	}
+
+	config := elcontracts.Config{}
+	chainReader, err := testclients.NewTestChainReaderFromConfig(anvilHttpEndpoint, config)
+	require.NoError(t, err)
+
+	_ = contractAddrs
+	_ = operator
+	_ = chainReader
+
+	t.Run("try to get a staker shares with invalid config", func(t *testing.T) {
+		// GetStakerShares needs a correct DelegationManagerAddress
+		_, _, err := chainReader.GetStakerShares(context.Background(), common.HexToAddress(operator.Address))
+		require.Error(t, err)
+	})
+
+	t.Run("try to get the delegated operator shares with invalid config", func(t *testing.T) {
+		// GetDelegatedOperator needs a correct DelegationManagerAddress
+		_, err := chainReader.GetDelegatedOperator(
+			context.Background(),
+			common.HexToAddress(operator.Address),
+			big.NewInt(0),
+		)
+		require.Error(t, err)
+	})
+
+	t.Run("try to get the number of operator sets for an operator with invalid config", func(t *testing.T) {
+		// GetNumOperatorSetsForOperator needs a correct AllocationManagerAddress
+		_, err := chainReader.GetNumOperatorSetsForOperator(context.Background(), common.HexToAddress(operator.Address))
+		require.Error(t, err)
+	})
+
+	t.Run("try to get the operator sets for an operator with invalid config", func(t *testing.T) {
+		// GetOperatorSetsForOperator needs a correct AllocationManagerAddress
+		_, err := chainReader.GetOperatorSetsForOperator(context.Background(), common.HexToAddress(operator.Address))
+		require.Error(t, err)
+	})
+
+	t.Run("try to check if the operator is registered in an operator set with set id 0 and an invalid config",
+		func(t *testing.T) {
+			// IsOperatorRegisteredWithOperatorSet with setId 0 needs a correct AVSDirectory
+			testAddr := common.HexToAddress(testutils.ANVIL_FIRST_ADDRESS)
+			operatorSetId := uint32(0)
+			operatorSet := allocationmanager.OperatorSet{
+				Avs: testAddr,
+				Id:  operatorSetId,
+			}
+			_, err := chainReader.IsOperatorRegisteredWithOperatorSet(
+				context.Background(),
+				common.HexToAddress(operator.Address),
+				operatorSet,
+			)
+			require.Error(t, err)
+		},
+	)
+
+	t.Run("try to check if the operator is registered in an operator set with set id 1 and an invalid config",
+		func(t *testing.T) {
+			// IsOperatorRegisteredWithOperatorSet with setId 1 needs a correct AllocationManagerAddress
+			testAddr := common.HexToAddress(testutils.ANVIL_FIRST_ADDRESS)
+			operatorSetId := uint32(1)
+			operatorSet := allocationmanager.OperatorSet{
+				Avs: testAddr,
+				Id:  operatorSetId,
+			}
+			_, err := chainReader.IsOperatorRegisteredWithOperatorSet(
+				context.Background(),
+				common.HexToAddress(operator.Address),
+				operatorSet,
+			)
+			require.Error(t, err)
+		},
+	)
+
+	t.Run("try to get the operators for an operator set with set id 1 and an invalid config",
+		func(t *testing.T) {
+			// GetOperatorsForOperatorSet needs a correct AllocationManagerAddress
+			testAddr := common.HexToAddress(testutils.ANVIL_FIRST_ADDRESS)
+			operatorSetId := uint32(1)
+			operatorSet := allocationmanager.OperatorSet{
+				Avs: testAddr,
+				Id:  operatorSetId,
+			}
+			_, err := chainReader.GetOperatorsForOperatorSet(
+				context.Background(),
+				operatorSet,
+			)
+			require.Error(t, err)
+		},
+	)
+
+	t.Run("try to get the number of operators for an operator set with set id 1 and an invalid config",
+		func(t *testing.T) {
+			// GetNumOperatorsForOperatorSet needs a correct AllocationManagerAddress
+			testAddr := common.HexToAddress(testutils.ANVIL_FIRST_ADDRESS)
+			operatorSetId := uint32(1)
+			operatorSet := allocationmanager.OperatorSet{
+				Avs: testAddr,
+				Id:  operatorSetId,
+			}
+			_, err := chainReader.GetNumOperatorsForOperatorSet(
+				context.Background(),
+				operatorSet,
+			)
+			require.Error(t, err)
+		},
+	)
+
+	t.Run("try to get the strategies for an operator set with set id 1 and an invalid config",
+		func(t *testing.T) {
+			// GetStrategiesForOperatorSet needs a correct AllocationManagerAddress
+			testAddr := common.HexToAddress(testutils.ANVIL_FIRST_ADDRESS)
+			operatorSetId := uint32(1)
+			operatorSet := allocationmanager.OperatorSet{
+				Avs: testAddr,
+				Id:  operatorSetId,
+			}
+			_, err := chainReader.GetStrategiesForOperatorSet(
+				context.Background(),
+				operatorSet,
+			)
+			require.Error(t, err)
+		},
+	)
+}