anchor.diff:      MiningTime = round(timer:now_diff(EndTime, StartTime) * 1.5)
                    div (1000 * Length),
   
  -    Top1 = request(old_node1, [v2, 'top'], #{}, Cfg),
  -    ct:log("Node 1 top: ~p~n", [Top1]),
  -    Height1 = request(old_node1, [v2, 'block-by-height'], #{height => Length}, Cfg),
  -    ct:log("Node 1 at height ~p: ~p~n", [Length, Height1]),
  -    Height2 = request(old_node2, [v2, 'block-by-height'], #{height => Length}, Cfg),
  -    ct:log("Node 2 at height ~p: ~p~n", [Length, Height2]),
  +    {ok, 200, Top1} = request(old_node1, 'GetTop', #{}),
  +    ct:log("Node 1 top: ~p", [Top1]),
  +    {ok, 200, Height1} = request(old_node1, 'GetBlockByHeight', #{height => Length}),
  +    ct:log("Node 1 at height ~p: ~p", [Length, Height1]),
  +    {ok, 200, Height2} = request(old_node2, 'GetBlockByHeight', #{height => Length}),
  +    ct:log("Node 2 at height ~p: ~p", [Length, Height2]),
   
       %% Checks node 1 and 2 are synchronized
       ?assertEqual(Height1, Height2),
  
positive.code:     %% Create a chain long enough to need 10 seconds to fetch it
      Length = BlocksPerSecond * 20,
  
      setup_nodes([?OLD_NODE1, ?OLD_NODE2], Cfg),
  
      start_node(old_node1, Cfg),
      wait_for_value({height, 0}, [old_node1], NodeStartupTime, Cfg),
  
      StartTime = os:timestamp(),
      wait_for_value({height, Length}, [old_node1], Length * ?MINING_TIMEOUT, Cfg),
      EndTime = os:timestamp(),
      %% Average mining time per block plus 50% extra
      MiningTime = round(timer:now_diff(EndTime, StartTime) * 1.5)
                   div (1000 * Length),
  
      B1 = request(old_node1, [v2, 'block-by-height'], #{height => Length}, Cfg),
      ct:log("Node 1 at height ~p: ~p~n", [Length, B1]),
  
      %% Start fetching the chain
      start_node(old_node2, Cfg),
      wait_for_value({height, 0}, [old_node2], NodeStartupTime, Cfg),
      ct:log("Node 2 ready to go"),
  
      %% we are fetching blocks stop node1 now
      kill_node(old_node1, Cfg),
      Top2 = request(old_node2, [v2, 'top'], #{}, Cfg),
      ct:log("Node 2 top: ~p~n", [Top2]),
      Height = maps:get(height, Top2),
      case Height >= Length of
           true -> {skip, already_synced_when_stopped};
           false ->
              start_node(old_node1, Cfg),
              wait_for_value({height, Length}, [old_node2], (Length - Height) * MiningTime, Cfg),
              B2 = request(old_node2, [v2, 'block-by-height'], #{height => Length}, Cfg),
              ct:log("Node 2 at height ~p: ~p~n", [Length, B2]),
              ?assertEqual(B1, B2)
      end.
  
negative.code:     wait_for_value({height, Length * 5}, [net1_node1, net1_node2, net2_node1, net2_node2],
                      Length * 2 * ?MINING_TIMEOUT, Cfg),
  
      {ok, 200, C1} = request(net1_node1, 'GetBlockByHeight', #{height => Length * 5}),
      {ok, 200, C2} = request(net1_node2, 'GetBlockByHeight', #{height => Length * 5}),
      {ok, 200, C3} = request(net2_node1, 'GetBlockByHeight', #{height => Length * 5}),
      {ok, 200, C4} = request(net2_node2, 'GetBlockByHeight', #{height => Length * 5}),
  
      %% Check the the chains forked
      ?assertEqual(C1, C2),
  