anchor.diff:  
       let saveNeoBlock neoBlock =
           client.Cypher
  -            .Create("(b:NeoBlock {param})")
  +            .Create("(b:Block {param})")
               .WithParam("param", neoBlock)
               .Return<NeoBlock>("b")
               .Results
               .Single()
   
       let neoBlockOfBlock (block: Block) hash =
  -        for trans in block.Transactions do
  -            neoTransOfTrans trans hash
           let neoBlock = 
               { Hash = hash
                 Timestamp = new DateTimeOffset(block.Timestamp, new TimeSpan(0L))  }
  -        saveNeoBlock neoBlock
  +        let savedNeoBlock = saveNeoBlock neoBlock
  +        for trans in block.Transactions do
  +            neoTransOfTrans trans hash
  +        savedNeoBlock
    
  -    let scanBlocks (prevBlock, currBlock) nextBlock =
  +    let scanBlocks (prevBlock, currBlock) (nextBlock: Block) =
           match prevBlock, currBlock with
  -        | Some prevNeoBlock, Some currNeoBlock ->
  -            let nextNeoBlock = neoBlockOfBlock nextBlock currNeoBlock.Hash
  -            printfn "did third save"
  +        | Some prevNeoBlock, Some currBlock ->
  +            let currNeoBlock = neoBlockOfBlock currBlock (Conversion.littleEndianBytesToHexString nextBlock.Hash)
               blockRelations prevNeoBlock currNeoBlock
  -            printfn "did first relation"
  -            Some currNeoBlock, Some nextNeoBlock
  -        | None, Some currNeoBlock ->
  -            let nextNeoBlock = neoBlockOfBlock nextBlock currNeoBlock.Hash
  -            printfn "did second save"
  -            Some currNeoBlock, Some nextNeoBlock
  +            Some currNeoBlock, Some nextBlock
  +        | None, Some currBlock ->
  +            let currNeoBlock = neoBlockOfBlock currBlock (Conversion.littleEndianBytesToHexString nextBlock.Hash)
  +            Some currNeoBlock, Some nextBlock
           | None, None -> 
  -            // TODO assumes first input is the genersis block, this will need to change to make it restartable
  -            let nextNeoBlock = neoBlockOfBlock nextBlock "0000000000000000000000000000000000000000000000000000000000000000"
  -            printfn "did first save"
  -            None, Some nextNeoBlock
  +            None, Some nextBlock
           | _ -> failwith "assert false"
   
       let load() =
  
positive.code:     // TODO feels like we could have a generic save method
      let saveNeoOutput transactionHash neoOutput =
          client.Cypher
              .Create("(o:NeoOutput {param})")
              .WithParam("param", neoOutput)
              .With("o")
              .Match("(t:NeoTransaction)")
              .Where(fun t -> t.TransactionHash = transactionHash)
              .CreateUnique("t-[:output]->o")
              .Return<NeoOutput>("o")
  
negative.code: 
      let saveNeoInput transactionHash neoInput =
          client.Cypher
              .Create("(i:Input {param})")
              .WithParam("param", neoInput)
              .With("i")
              .Match("(t:Transaction)")
              .Where(fun t -> t.TransactionHash = transactionHash)
              .CreateUnique("t-[:input]->i")
              .Return<NeoInput>("i")
  