anchor.diff:  
       let lookupTransaction transHash i =
           client.Cypher
  -            .Match("(t:NeoTransaction)-[:output]->(o:NeoOutput)")
  +            .Match("(t:Transaction)-[:output]->(o:Output)")
               .Where(fun t -> t.TransactionHash = transHash)
               .AndWhere(fun o -> o.Index = i)
               .Return<NeoOutput>("o")
  
positive.code:         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 transaction = {emptyTransaction with TotalInputs = totalInputs; TotalOutputs = totalOutputs}
          updateTransaction transaction
          tansactionRelations transaction hash
  
      let blockRelations prev curr =
          client.Cypher
              .Match("(p:NeoBlock)", "(c:NeoBlock)")
              .Where(fun p -> p.Hash = prev.Hash)
              .AndWhere(fun c -> c.Hash = curr.Hash)
              .CreateUnique("p-[:next]->c")
  
negative.code: 
      let tansactionRelations trans blockHash =
          client.Cypher
              .Match("(t:Transaction)", "(b:Block)")
              .Where(fun t -> t.TransactionHash = trans.TransactionHash)
              .AndWhere(fun b -> b.Hash = blockHash)
              .CreateUnique("t-[:belongsTo]->b")
  