anchor.diff:          let outputs = Array.mapi (neoOutputOfOutput transactionHash) trans.Outputs
           let totalInputs = inputs |> Seq.sumBy (fun x -> x.Value)
           // TODO this assumes when addresss is none, the payment goes to the minor, this is usually but not always true
  -        let totalOutputs = outputs |> Seq.filter (fun x -> x.Address = null) |> Seq.sumBy (fun x -> x.Value)
  +        let totalOutputs = outputs |> Seq.filter (fun x -> x.Address <> null) |> Seq.sumBy (fun x -> x.Value)
           let transaction = {emptyTransaction with TotalInputs = totalInputs; TotalOutputs = totalOutputs}
           updateTransaction transaction
           tansactionRelations transaction hash
   
       let blockRelations prev curr =
           client.Cypher
  -            .Match("(p:NeoBlock)", "(c:NeoBlock)")
  +            .Match("(p:Block)", "(c:Block)")
               .Where(fun p -> p.Hash = prev.Hash)
               .AndWhere(fun c -> c.Hash = curr.Hash)
               .CreateUnique("p-[:next]->c")
  
positive.code:             .ExecuteWithoutResults()
  
      let updateTransaction (trans: NeoTransaction) =
          client.Cypher
              .Match("(t:NeoTransaction)")
              .Where(fun t -> t.TransactionHash = trans.TransactionHash)
              .Set("t.TotalInputs = {inputparam}")
              .WithParam("inputparam", trans.TotalInputs)
  
negative.code: 
      let saveNeoTrans neoTrans =
          client.Cypher
              .Create("(t:Transaction {param})")
              .WithParam("param", neoTrans)
              .Return<NeoTransaction>("t")
              .Results
  