anchor.diff:  
       %% Coinbase.
       ct:pal("Calling coinbase\n"),
  -    {CoinBaseValue,_} = call_compute_func(NodeName, CPubkey, CPrivkey,
  -                                          EncodedContractPubkey,
  -                                          <<"coinbase">>, <<"()">>),
  +    {CoinBaseValue,CBHeader} = call_compute_func(NodeName, CPubkey, CPrivkey,
  +                                                 EncodedContractPubkey,
  +                                                 <<"coinbase">>, <<"()">>),
       #{<<"value">> := CoinBase} = decode_data(<<"address">>, CoinBaseValue),
       ct:pal("CoinBase ~p\n", [CoinBase]),
  +    #{<<"prev_key_hash">> := CBKeyHash} = CBHeader,
  +    ExpectedBeneficiary = aec_base58c:encode(account_pubkey, <<CoinBase:256>>),
  +    ?assertMatch({ok, 200, #{<<"beneficiary">> := ExpectedBeneficiary}},
  +                 get_key_block(CBKeyHash)),
   
       %% Block timestamp.
       ct:pal("Calling timestamp\n"),
  -    {TimeStampValue,_} = call_compute_func(NodeName, CPubkey, CPrivkey,
  -                                           EncodedContractPubkey,
  -                                           <<"timestamp">>, <<"()">>),
  +    {TimeStampValue,TSHeader} = call_compute_func(NodeName, CPubkey, CPrivkey,
  +                                                  EncodedContractPubkey,
  +                                                  <<"timestamp">>, <<"()">>),
       #{<<"value">> := TimeStamp} = decode_data(<<"int">>, TimeStampValue),
       ct:pal("Timestamp ~p\n", [TimeStamp]),
  +    ?assertEqual(maps:get(<<"time">>, TSHeader), TimeStamp),
   
       %% Block height.
       ct:pal("Calling block_height\n"),
  -    {HeightValue,_} = call_compute_func(NodeName, DPubkey, DPrivkey,
  +    {HeightValue,HeightHeader} = call_compute_func(NodeName, DPubkey, DPrivkey,
                                           EncodedContractPubkey,
                                           <<"block_height">>, <<"()">>),
       #{<<"value">> := BlockHeight} = decode_data(<<"int">>, HeightValue),
       ct:pal("Block height ~p\n", [BlockHeight]),
  +    ?assertEqual(maps:get(<<"height">>, HeightHeader), BlockHeight),
   
       %% Difficulty.
       ct:pal("Calling difficulty\n"),
  -    {DiffValue,_} = call_compute_func(NodeName, DPubkey, DPrivkey,
  -                                      EncodedContractPubkey,
  -                                      <<"difficulty">>, <<"()">>),
  +    {DiffValue,DiffHeader} = call_compute_func(NodeName, DPubkey, DPrivkey,
  +                                               EncodedContractPubkey,
  +                                               <<"difficulty">>, <<"()">>),
       #{<<"value">> := Difficulty} = decode_data(<<"int">>, DiffValue),
       ct:pal("Difficulty ~p\n", [Difficulty]),
  +    #{<<"prev_key_hash">> := DiffKeyHash} = DiffHeader,
  +    {ok, 200, #{<<"target">> := Target}} = get_key_block(DiffKeyHash),
  +    ?assertMatch(Difficulty, aec_pow:target_to_difficulty(Target)),
   
       %% Gas limit.
       ct:pal("Calling gas_limit\n"),
  
positive.code: get_top() ->
      Host = external_address(),
      http_request(Host, get, "blocks/top", []).
  
  get_key_blocks_current_height() ->
      Host = external_address(),
  
negative.code: 
      %% Value.
      ct:pal("Calling call_value\n"),
      ExpectedValue = 5,
      {CVValue,_} = call_compute_func(NodeName, BPubkey, BPrivkey,
                                      EncodedContractPubkey,
                                      <<"call_value">>, <<"()">>,
                                      #{amount => ExpectedValue}
                                     ),
      #{<<"value">> := CallValue} = decode_data(<<"int">>, CVValue),
      ct:pal("Call value ~p\n", [CallValue]),
      ?assertEqual(ExpectedValue, CallValue),
      ct:pal("Calling nested_value\n"),
      {NestedValue, _} = call_compute_func(NodeName, BPubkey, BPrivkey,
                                           EncodedContractPubkey,
                                           <<"nested_value">>, <<"(42)">>),
      ct:pal("Nested value ~p\n", [NestedValue]),
  
      %% Gas price.
      ct:pal("Calling call_gas_price\n"),
      ExpectedGasPrice = 2,
      {GPValue,_} = call_compute_func(NodeName, BPubkey, BPrivkey,
                                      EncodedContractPubkey,
                                      <<"call_gas_price">>, <<"()">>,
                                      #{gas_price => ExpectedGasPrice}
                                     ),
      #{<<"value">> := GasPrice} = decode_data(<<"int">>, GPValue),
      ct:pal("Gas price ~p\n", [GasPrice]),
      ?assertEqual(ExpectedGasPrice, GasPrice),
  
      %% Account balances.
      ct:pal("Calling get_balance twice\n"),
  