anchor.diff:  
       %% Value.
       ct:pal("Calling call_value\n"),
  +    ExpectedValue = 5,
       {CVValue,_} = call_compute_func(NodeName, BPubkey, BPrivkey,
                                       EncodedContractPubkey,
  -                                    <<"call_value">>, <<"()">>),
  +                                    <<"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)">>),
  +    {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">>, <<"()">>),
  +                                    <<"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"),
  
positive.code:                                     <<"gas_limit">>, <<"()">>),
      #{<<"value">> := GasLimit} = decode_data(<<"int">>, GLValue),
      ct:pal("Gas limit ~p\n", [GasLimit]),
  
      aecore_suite_utils:mine_key_blocks(NodeName, 3),
  
  
negative.code: 
      %% Coinbase.
      ct:pal("Calling coinbase\n"),
      {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,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,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,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"),
  