packages feed

haskoin-node-2.6.0: test/unit/Haskoin/Node/ChainSpec.hs

{-# OPTIONS_GHC -Wno-deprecations #-}

-- | Header chain process driven by fake peers.
module Haskoin.Node.ChainSpec (spec) where

import Control.Concurrent.Async (link, withAsync)
import Control.Concurrent.STM
import Control.Monad (forM_, forever, void)
import Data.Text (Text)
import Data.Time.Clock (NominalDiffTime)
import Database.RocksDB (DB)
import Haskoin
import Haskoin.Node
import Haskoin.Node.Peer.Lock (Lock (..))
import Haskoin.Node.Test
import NQE
import Test.HUnit (assertFailure)
import Test.Hspec hiding (pending)

data ChainTest = ChainTest
  { chain :: !Chain,
    events :: !(Inbox ChainEvent),
    peerPub :: !(Publisher PeerEvent),
    net :: !Network
  }

-- | Peer whose outgoing messages are captured instead of sent.
data FakePeer = FakePeer
  { peer :: !Peer,
    inbox :: !(Inbox PeerMessage)
  }

withChainTest :: Network -> NominalDiffTime -> (ChainTest -> IO a) -> IO a
withChainTest net to f = withTestDB $ \db -> withChainOn net to db f

withChainOn ::
  Network -> NominalDiffTime -> DB -> (ChainTest -> IO a) -> IO a
withChainOn net to db f =
  withTestLogger $ \logger ->
    withPublisher $ \pub ->
      withSubscription pub $ \events ->
        withPublisher $ \peerPub ->
          withChain (ChainConfig db Nothing net pub to logger) $ \chain ->
            f ChainTest {chain, events, peerPub, net}

newFakePeer :: ChainTest -> Text -> IO FakePeer
newFakePeer ct label = do
  (inbox, mailbox) <- newMailbox
  busy <- newTVarIO Free
  pending <- newTVarIO 0
  return
    FakePeer
      { peer = Peer {mailbox, pub = ct.peerPub, label, busy, pending},
        inbox
      }

connectPeer :: ChainTest -> Text -> IO FakePeer
connectPeer ct label = do
  fp <- newFakePeer ct label
  chainPeerConnected ct.chain fp.peer
  return fp

describeMessage :: PeerMessage -> String
describeMessage KillPeer = "disconnection"
describeMessage (SendMessage m) = show (commandToString (msgType m))

-- | Next header request sent to the peer, skipping 'MSendHeaders'.
expectGetHeaders :: FakePeer -> IO GetHeaders
expectGetHeaders fp =
  within 10 ("header request to " <> show fp.peer) go
  where
    go =
      receive fp.inbox >>= \case
        SendMessage (MGetHeaders g) -> return g
        SendMessage MSendHeaders -> go
        m -> assertFailure $ "Expected header request, got " <> describeMessage m

expectSendHeaders :: FakePeer -> IO ()
expectSendHeaders fp =
  receiveWithin 10 "sendheaders" fp.inbox $ \case
    SendMessage MSendHeaders -> Just ()
    _ -> Nothing

expectKilled :: FakePeer -> IO ()
expectKilled fp =
  receiveWithin 10 ("disconnection of " <> show fp.peer) fp.inbox $ \case
    KillPeer -> Just ()
    _ -> Nothing

-- | Fail if the peer is asked for headers or disconnected in time window.
expectNoRequest :: Double -> FakePeer -> IO ()
expectNoRequest s fp =
  expectNothingWithin s ("request to " <> show fp.peer) fp.inbox $ \case
    SendMessage (MGetHeaders _) -> Just ()
    KillPeer -> Just ()
    _ -> Nothing

sendHeaders :: ChainTest -> FakePeer -> [BlockHeader] -> IO ()
sendHeaders ct fp = chainHeaders ct.chain fp.peer

-- | Wait for a header request and answer it from the provided chain.
answer :: ChainTest -> FakePeer -> [BlockHeader] -> IO [BlockHeader]
answer ct fp hs = do
  g <- expectGetHeaders fp
  let r = serveHeaders ct.net hs g
  sendHeaders ct fp r
  return r

-- | Answer all header requests from the chain in the variable. Counts the
-- requests.
withServer ::
  ChainTest -> FakePeer -> TVar [BlockHeader] -> (TVar Int -> IO a) -> IO a
withServer ct fp var f = do
  count <- newTVarIO 0
  let go = forever $ do
        g <- receiveMatch fp.inbox $ \case
          SendMessage (MGetHeaders g) -> Just g
          _ -> Nothing
        atomically $ modifyTVar count (+ 1)
        hs <- readTVarIO var
        sendHeaders ct fp (serveHeaders ct.net hs g)
  withAsync go $ \a -> link a >> f count

waitHeight :: ChainTest -> BlockHeight -> IO BlockNode
waitHeight ct h = do
  eventually 30 ("best height " <> show h) $
    (== h) . (.height) <$> chainGetBest ct.chain
  chainGetBest ct.chain

bestHash :: ChainTest -> IO BlockHash
bestHash ct = headerHash . (.header) <$> chainGetBest ct.chain

-- | Sync a fresh peer to the provided chain.
syncPeer :: ChainTest -> Text -> [BlockHeader] -> IO FakePeer
syncPeer ct label hs = do
  fp <- connectPeer ct label
  _ <- answer ct fp hs
  _ <- waitHeight ct (fromIntegral (length hs))
  expectSendHeaders fp
  return fp

-- | The header with the first nonce for which its hash is above its target.
-- Only its proof of work is wrong: its bits, time and parent are those of a
-- valid header.
invalidPow :: BlockHeader -> BlockHeader
invalidPow h =
  case [h' | n <- [0 ..], let h' = withNonce n, blockPOW (headerHash h') > target] of
    h' : _ -> h'
    [] -> h
  where
    (target, _) = decodeCompact h.bits
    withNonce n =
      BlockHeader
        { version = h.version,
          prev = h.prev,
          merkle = h.merkle,
          timestamp = h.timestamp,
          bits = h.bits,
          nonce = n
        }

spec :: Spec
spec = forM_ [btcRegTest, bchRegTest] $ \net ->
  describe ("header chain on " <> net.name) $ do
    t0 <- runIO $ subtract 6000 <$> nowTimestamp
    let main = mkHeaders net 0 net.genesisHeader t0 4500
        short = take 20 main
        hashAt i = headerHash (main !! (i - 1))
        nodeHash = headerHash . (.header)
        fast = withChainTest net 1
        slow = withChainTest net 600

    describe "initial sync" $ do
      it "requests headers in batches until the peer runs out" $ slow $ \ct -> do
        a <- connectPeer ct "a"
        g1 <- expectGetHeaders a
        take 1 g1.locator `shouldBe` [headerHash net.genesisHeader]
        sendHeaders ct a (serveHeaders net main g1)
        g2 <- expectGetHeaders a
        take 1 g2.locator `shouldBe` [hashAt 2000]
        sendHeaders ct a (serveHeaders net main g2)
        g3 <- expectGetHeaders a
        take 1 g3.locator `shouldBe` [hashAt 4000]
        r3 <- return (serveHeaders net main g3)
        length r3 `shouldBe` 500
        sendHeaders ct a r3
        expectSendHeaders a
        expectNoRequest 0.5 a
        best <- waitHeight ct 4500
        nodeHash best `shouldBe` hashAt 4500

      it "publishes best block and synced events once" $ slow $ \ct -> do
        a <- connectPeer ct "a"
        var <- newTVarIO main
        withServer ct a var $ \count -> do
          bn <- receiveWithin 30 "synced event" ct.events $ \case
            ChainSynced bn -> Just bn
            _ -> Nothing
          bn.height `shouldBe` 4500
          chainIsSynced ct.chain `shouldReturn` True
          readTVarIO count `shouldReturn` 3
          expectNothingWithin 0.5 "second synced event" ct.events $ \case
            ChainSynced _ -> Just ()
            _ -> Nothing

      it "does not consider old headers synced" $ slow $ \ct -> do
        let old = mkHeaders net 0 net.genesisHeader 1500000000 10
        _ <- syncPeer ct "a" old
        chainIsSynced ct.chain `shouldReturn` False

      it "stops asking a peer that sends no headers" $ slow $ \ct -> do
        a <- connectPeer ct "a"
        _ <- expectGetHeaders a
        sendHeaders ct a []
        expectSendHeaders a
        expectNoRequest 1 a

      it "syncs against every peer that connects" $ slow $ \ct -> do
        _ <- syncPeer ct "a" (take 10 main)
        b <- connectPeer ct "b"
        _ <- answer ct b (take 30 main)
        void $ waitHeight ct 30

      it "ignores duplicate connection events" $ slow $ \ct -> do
        a <- connectPeer ct "a"
        chainPeerConnected ct.chain a.peer
        _ <- answer ct a short
        expectSendHeaders a
        expectNoRequest 1 a

      it "keeps headers across restarts" $ withTestDB $ \db -> do
        withChainOn net 600 db $ \ct -> void $ syncPeer ct "a" short
        withChainOn net 600 db $ \ct -> do
          bn <- receiveWithin 10 "best block" ct.events $ \case
            ChainBestBlock bn -> Just bn
            _ -> Nothing
          bn.height `shouldBe` 20
          bestHash ct `shouldReturn` hashAt 20

    describe "announcements" $ do
      it "requests headers when an unknown block is announced by inventory" $
        slow $ \ct -> do
          a <- syncPeer ct "a" (take 10 main)
          chainBlocksAnnounced ct.chain a.peer [hashAt 109]
          _ <- answer ct a (take 109 main)
          void $ waitHeight ct 109

      it "ignores inventory announcements of known blocks" $ slow $ \ct -> do
        a <- syncPeer ct "a" (take 10 main)
        chainBlocksAnnounced ct.chain a.peer [hashAt 5, hashAt 10]
        expectNoRequest 1 a

      it "imports announced headers that connect" $ slow $ \ct -> do
        a <- syncPeer ct "a" (take 10 main)
        sendHeaders ct a [main !! 10]
        _ <- waitHeight ct 11
        expectNoRequest 0.5 a

      it "requests headers when announced headers do not connect" $
        slow $ \ct -> do
          a <- syncPeer ct "a" (take 10 main)
          sendHeaders ct a (take 5 (drop 49 main))
          _ <- answer ct a (take 54 main)
          void $ waitHeight ct 54

      it "continues syncing a peer that sends a full batch unsolicited" $
        slow $ \ct -> do
          a <- connectPeer ct "a"
          b <- connectPeer ct "b"
          _ <- expectGetHeaders a
          sendHeaders ct b (take 2000 main)
          _ <- waitHeight ct 2000
          sendHeaders ct a []
          g <- expectGetHeaders b
          take 1 g.locator `shouldBe` [hashAt 2000]

      it "asks a peer that announces an unknown block while another peer syncs" $
        slow $ \ct -> do
          a <- connectPeer ct "a"
          b <- connectPeer ct "b"
          -- a holds the turn and never answers
          _ <- expectGetHeaders a
          chainBlocksAnnounced ct.chain b.peer [hashAt 100]
          g <- expectGetHeaders b
          take 1 g.locator `shouldBe` [headerHash net.genesisHeader]

      it "asks an announcing peer only once until it answers" $
        slow $ \ct -> do
          a <- connectPeer ct "a"
          b <- connectPeer ct "b"
          _ <- expectGetHeaders a
          chainBlocksAnnounced ct.chain b.peer [hashAt 100]
          _ <- expectGetHeaders b
          chainBlocksAnnounced ct.chain b.peer [hashAt 101]
          sendHeaders ct b (take 5 (drop 49 main))
          expectNoRequest 1 b
          -- headers that connect answer the request
          sendHeaders ct b (take 5 main)
          _ <- waitHeight ct 5
          chainBlocksAnnounced ct.chain b.peer [hashAt 102]
          void $ expectGetHeaders b

      it "keeps syncing peer when another peer announces headers" $
        slow $ \ct -> do
          a <- connectPeer ct "a"
          b <- connectPeer ct "b"
          g <- expectGetHeaders a
          sendHeaders ct b (take 5 main)
          _ <- waitHeight ct 5
          sendHeaders ct a (serveHeaders net short g)
          _ <- waitHeight ct 20
          expectSendHeaders a
          -- b gets its turn once a is done
          void $ answer ct b (take 5 main)

      it "ignores messages from peers that are not connected" $
        slow $ \ct -> do
          x <- newFakePeer ct "x"
          sendHeaders ct x (take 5 main)
          chainBlocksAnnounced ct.chain x.peer [hashAt 5]
          expectNoRequest 1 x
          (.height) <$> chainGetBest ct.chain `shouldReturn` 0

    describe "reorganizations" $ do
      let fork n = mkHeaders net 1 (main !! 14) (t0 + 100) n
      it "keeps the first chain it saw when a fork has the same work" $ slow $ \ct -> do
        a <- syncPeer ct "a" short
        -- five headers on block 15 reach height 20, with the same work
        sendHeaders ct a (fork 5)
        let tip = headerHash (last (fork 5))
        eventually 10 "fork stored" $
          (/= Nothing) <$> chainGetBlock ct.chain tip
        bestHash ct `shouldReturn` hashAt 20

      it "switches to a fork with more work" $ slow $ \ct -> do
        a <- syncPeer ct "a" short
        sendHeaders ct a (fork 10)
        best <- waitHeight ct 25
        nodeHash best `shouldBe` headerHash (last (fork 10))
        chainBlockMain ct.chain (hashAt 20) `shouldReturn` False
        chainBlockMain ct.chain (hashAt 15) `shouldReturn` True
        Just old <- chainGetBlock ct.chain (hashAt 20)
        split <- chainGetSplitBlock ct.chain old best
        nodeHash split `shouldBe` hashAt 15

      it "stays on the chain with more work" $ slow $ \ct -> do
        a <- syncPeer ct "a" short
        sendHeaders ct a (fork 3)
        let tip = headerHash (last (fork 3))
        eventually 10 "fork stored" $
          (/= Nothing) <$> chainGetBlock ct.chain tip
        bestHash ct `shouldReturn` hashAt 20
        chainBlockMain ct.chain tip `shouldReturn` False

    describe "misbehaving peers" $ do
      it "disconnects a peer that sends headers with invalid proof of work" $
        slow $ \ct -> do
          a <- connectPeer ct "a"
          _ <- expectGetHeaders a
          sendHeaders ct a [invalidPow (main !! 0)]
          expectKilled a

      it "publishes the best block when a batch fails after valid headers" $
        slow $ \ct -> do
          a <- connectPeer ct "a"
          _ <- expectGetHeaders a
          sendHeaders ct a (take 5 main <> [invalidPow (main !! 5)])
          expectKilled a
          bn <- receiveWithin 10 "best block at height 5" ct.events $ \case
            ChainBestBlock bn | bn.height == 5 -> Just bn
            _ -> Nothing
          nodeHash bn `shouldBe` hashAt 5

      it "ends the turn of a peer whose full batch brings no new header" $
        slow $ \ct -> do
          a <- connectPeer ct "a"
          b <- connectPeer ct "b"
          _ <- answer ct a main
          _ <- waitHeight ct 2000
          -- asked for the headers after 2000, a sends the first 2000 again
          _ <- expectGetHeaders a
          sendHeaders ct a (take 2000 main)
          expectSendHeaders a
          g <- expectGetHeaders b
          take 1 g.locator `shouldBe` [hashAt 2000]

      it "disconnects a peer that sends headers that do not form a chain" $
        slow $ \ct -> do
          a <- connectPeer ct "a"
          _ <- expectGetHeaders a
          sendHeaders ct a [main !! 0, main !! 2]
          expectKilled a

      it "syncs from another peer after disconnecting a misbehaving one" $
        slow $ \ct -> do
          a <- connectPeer ct "a"
          b <- connectPeer ct "b"
          _ <- expectGetHeaders a
          sendHeaders ct a [invalidPow (main !! 0)]
          expectKilled a
          _ <- answer ct b short
          void $ waitHeight ct 20

      it "disconnects an unresponsive syncing peer and moves on" $
        fast $ \ct -> do
          a <- connectPeer ct "a"
          b <- connectPeer ct "b"
          _ <- expectGetHeaders a
          expectKilled a
          _ <- answer ct b short
          void $ waitHeight ct 20

      it "moves on when the syncing peer disconnects" $ slow $ \ct -> do
        a <- connectPeer ct "a"
        b <- connectPeer ct "b"
        _ <- expectGetHeaders a
        chainPeerDisconnected ct.chain a.peer
        _ <- answer ct b short
        void $ waitHeight ct 20

      it "never asks a peer for headers after it disconnects" $
        slow $ \ct -> do
          a <- connectPeer ct "a"
          b <- connectPeer ct "b"
          _ <- expectGetHeaders a
          -- queue a again while it is syncing
          chainBlocksAnnounced ct.chain a.peer [hashAt 5]
          chainPeerDisconnected ct.chain a.peer
          _ <- answer ct b short
          _ <- waitHeight ct 20
          expectNoRequest 1 a

      it "waits for a peer reserved by someone else" $ fast $ \ct -> do
        other <- newOwner "other"
        a <- newFakePeer ct "a"
        True <- reservePeer other a.peer
        chainPeerConnected ct.chain a.peer
        expectNoRequest 1 a
        True <- releasePeer other a.peer
        void $ answer ct a short

      it "keeps its reservation when others try to release the peer" $
        slow $ \ct -> do
          other <- newOwner "other"
          a <- connectPeer ct "a"
          _ <- expectGetHeaders a
          False <- releasePeer other a.peer
          setFree a.peer
          fmap ownerName <$> peerHolder a.peer `shouldReturn` Just "Chain"
          False <- reservePeer other a.peer
          sendHeaders ct a []
          eventually 10 "peer released" $ (== Nothing) . fmap ownerName <$> peerHolder a.peer

    describe "stall recovery" $ do
      it "asks peers for headers when nothing happens for a while" $
        fast $ \ct -> do
          a <- syncPeer ct "a" (take 10 main)
          -- the peer finds blocks but never announces them
          var <- newTVarIO (take 30 main)
          withServer ct a var $ \_ -> void (waitHeight ct 30)

      it "recovers when the syncing peer stops responding" $ fast $ \ct -> do
        a <- connectPeer ct "a"
        _ <- expectGetHeaders a
        expectKilled a
        chainPeerDisconnected ct.chain a.peer
        b <- connectPeer ct "b"
        void $ answer ct b short

    describe "queries" $ do
      it "answers questions about the chain" $ slow $ \ct -> do
        _ <- syncPeer ct "a" short
        tip <- chainGetBest ct.chain
        Just anc <- chainGetAncestor ct.chain 10 tip
        nodeHash anc `shouldBe` hashAt 10
        ps <- chainGetParents ct.chain 15 tip
        map (.height) ps `shouldBe` [15 .. 19]
        map nodeHash ps `shouldBe` map hashAt [15 .. 19]
        chainGetBlock ct.chain (headerHash (main !! 100)) `shouldReturn` Nothing
        chainBlockMain ct.chain (headerHash (main !! 100)) `shouldReturn` False
        chainBlockMain ct.chain (hashAt 20) `shouldReturn` True
        Just n5 <- chainGetBlock ct.chain (hashAt 5)
        split <- chainGetSplitBlock ct.chain n5 tip
        nodeHash split `shouldBe` hashAt 5