diff --git a/Makefile b/Makefile
index 08b4b02d..4bda5dc1 100644
--- a/Makefile
+++ b/Makefile
@@ -19,7 +19,7 @@ mocks: ## generates mocks
 
 .PHONY: tests
 tests: ## runs all tests
-	go test -race ./... -timeout=5m
+	go test -race ./... -timeout=6m
 
 .PHONY: tests-cover
 tests-cover: ## run all tests with test coverge
diff --git a/chainio/clients/elcontracts/reader_test.go b/chainio/clients/elcontracts/reader_test.go
index 9244c698..9c45af36 100644
--- a/chainio/clients/elcontracts/reader_test.go
+++ b/chainio/clients/elcontracts/reader_test.go
@@ -1257,6 +1257,146 @@ func TestOperatorSetsWithWrongInput(t *testing.T) {
 	})
 }
 
+// The idea is to cover some cases where network can fail by passing a
+// cancelled context, so the binding returns an error
+func TestFailingNetwork(t *testing.T) {
+	read_clients, anvilHttpEndpoint := testclients.BuildTestReadClients(t)
+	ctx := context.Background()
+
+	subCtx, cancelFn := context.WithCancel(ctx)
+	cancelFn()
+
+	contractAddrs := testutils.GetContractAddressesFromContractRegistry(anvilHttpEndpoint)
+	operator := types.Operator{
+		Address: testutils.ANVIL_FIRST_ADDRESS,
+	}
+
+	t.Run("is operator registered", func(t *testing.T) {
+		isOperator, err := read_clients.ElChainReader.IsOperatorRegistered(subCtx, operator)
+		assert.Error(t, err)
+		assert.False(t, isOperator)
+	})
+
+	t.Run("get operator details", func(t *testing.T) {
+		operatorDetails, err := read_clients.ElChainReader.GetOperatorDetails(subCtx, operator)
+		assert.Error(t, err)
+		assert.Equal(t, types.Operator{}, operatorDetails)
+	})
+
+	t.Run("get strategy and underlying token", func(t *testing.T) {
+		strategyAddr := contractAddrs.Erc20MockStrategy
+		strategy, underlyingTokenAddr, err := read_clients.ElChainReader.GetStrategyAndUnderlyingToken(
+			subCtx,
+			strategyAddr,
+		)
+		assert.Error(t, err)
+		assert.Nil(t, strategy)
+		assert.Equal(t, common.Address{}, underlyingTokenAddr)
+	})
+
+	t.Run("get strategy and underlying ERC20 token", func(t *testing.T) {
+		strategyAddr := contractAddrs.Erc20MockStrategy
+		strategy, contractUnderlyingToken, underlyingTokenAddr, err := read_clients.ElChainReader.GetStrategyAndUnderlyingERC20Token(
+			subCtx,
+			strategyAddr,
+		)
+		assert.Error(t, err)
+		assert.Nil(t, strategy)
+		assert.Equal(t, common.Address{}, underlyingTokenAddr)
+		assert.Nil(t, contractUnderlyingToken)
+	})
+
+	t.Run("get operator shares in strategy", func(t *testing.T) {
+		shares, err := read_clients.ElChainReader.GetOperatorSharesInStrategy(
+			subCtx,
+			common.HexToAddress(operator.Address),
+			contractAddrs.Erc20MockStrategy,
+		)
+		assert.Error(t, err)
+		assert.Zero(t, shares)
+	})
+
+	t.Run("calculate delegation approval digest hash", func(t *testing.T) {
+		staker := common.Address{0x0}
+		delegationApprover := common.Address{0x0}
+		approverSalt := [32]byte{}
+		expiry := big.NewInt(0)
+		digest, err := read_clients.ElChainReader.CalculateDelegationApprovalDigestHash(
+			subCtx,
+			staker,
+			common.HexToAddress(operator.Address),
+			delegationApprover,
+			approverSalt,
+			expiry,
+		)
+		assert.Error(t, err)
+		assert.Empty(t, digest)
+	})
+
+	t.Run("calculate operator AVS registration digest hash", func(t *testing.T) {
+		avs := common.Address{0x0}
+		salt := [32]byte{}
+		expiry := big.NewInt(0)
+		digest, err := read_clients.ElChainReader.CalculateOperatorAVSRegistrationDigestHash(
+			subCtx,
+			common.HexToAddress(operator.Address),
+			avs,
+			salt,
+			expiry,
+		)
+		assert.Error(t, err)
+		assert.Empty(t, digest)
+	})
+
+	t.Run("get staker shares", func(t *testing.T) {
+		strategies, shares, err := read_clients.ElChainReader.GetStakerShares(
+			subCtx,
+			common.HexToAddress(operator.Address),
+		)
+		assert.Empty(t, strategies)
+		assert.Empty(t, shares)
+		assert.Error(t, err)
+	})
+
+	t.Run("get delegated operator", func(t *testing.T) {
+		blockNumber := big.NewInt(0)
+		address, err := read_clients.ElChainReader.GetDelegatedOperator(
+			subCtx,
+			common.HexToAddress(operator.Address),
+			blockNumber,
+		)
+
+		assert.Error(t, err)
+		assert.Equal(t, address, common.Address{})
+	})
+
+	t.Run("GetOperatorShares", func(t *testing.T) {
+		strategyAddr := contractAddrs.Erc20MockStrategy
+		strategies := []common.Address{strategyAddr}
+		shares, err := read_clients.ElChainReader.GetOperatorShares(
+			subCtx,
+			common.HexToAddress(operator.Address),
+			strategies,
+		)
+		assert.Error(t, err)
+		assert.Nil(t, shares)
+	})
+
+	t.Run("GetOperatorsShares", func(t *testing.T) {
+		operatorAddr := common.HexToAddress(operator.Address)
+		operators := []common.Address{operatorAddr}
+		strategyAddr := contractAddrs.Erc20MockStrategy
+		strategies := []common.Address{strategyAddr}
+		shares, err := read_clients.ElChainReader.GetOperatorsShares(
+			subCtx,
+			operators,
+			strategies,
+		)
+		assert.Error(t, err)
+		assert.Nil(t, shares)
+	})
+}
+
 func TestCreateRederFromConfig(t *testing.T) {
 	_, anvilHttpEndpoint := testclients.BuildTestClients(t)
 	testConfig := testutils.GetDefaultTestConfig()