packages feed

haskoin-core-2.0.0: src/Haskoin/Util/Arbitrary/Block.hs

{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE OverloadedRecordDot #-}

-- |
-- Module      : Haskoin.Test.Block
-- Copyright   : No rights reserved
-- License     : MIT
-- Maintainer  : jprupp@protonmail.ch
-- Stability   : experimental
-- Portability : POSIX
module Haskoin.Util.Arbitrary.Block where

import qualified Data.HashMap.Strict as HashMap
import Haskoin.Block
import Haskoin.Network.Data
import Haskoin.Transaction.Common (Tx, TxHash (..), txHash)
import Haskoin.Util.Arbitrary.Crypto
import Haskoin.Util.Arbitrary.Network
import Haskoin.Util.Arbitrary.Transaction
import Haskoin.Util.Arbitrary.Util
import Test.QuickCheck

-- | Block of arbitrary transactions. The header has the Merkle root of the
-- transactions when there are some. On a network without SegWit the
-- transactions have no witness, as a block of that network has none.
arbitraryBlock :: Network -> Gen Block
arbitraryBlock net = do
  h <- arbitraryBlockHeader
  c <- choose (0, 10)
  txs <- vectorOf c (arbitraryNetworkTx net)
  let header = case buildMerkleRoot (map txHash txs) of
        Right root -> (h :: BlockHeader) {merkle = root}
        Left _ -> h
  return $ Block header txs

-- | Arbitrary transaction of the kind a peer of the network sends: with or
-- without a witness where the network has SegWit, without one elsewhere.
arbitraryNetworkTx :: Network -> Gen Tx
arbitraryNetworkTx net
  | net.segWit = arbitraryTx net
  | otherwise = arbitraryLegacyTx net

-- | Block header with random hash.
arbitraryBlockHeader :: Gen BlockHeader
arbitraryBlockHeader =
  BlockHeader
    <$> arbitrary
    <*> arbitraryBlockHash
    <*> arbitraryHash256
    <*> arbitrary
    <*> arbitrary
    <*> arbitrary

-- | Arbitrary block hash.
arbitraryBlockHash :: Gen BlockHash
arbitraryBlockHash = BlockHash <$> arbitraryHash256

-- | Arbitrary 'GetBlocks' object with at least one block hash.
arbitraryGetBlocks :: Gen GetBlocks
arbitraryGetBlocks =
  GetBlocks
    <$> arbitrary
    <*> listOf1 arbitraryBlockHash
    <*> arbitraryBlockHash

-- | Arbitrary 'GetHeaders' object with at least one block header.
arbitraryGetHeaders :: Gen GetHeaders
arbitraryGetHeaders =
  GetHeaders
    <$> arbitrary
    <*> listOf1 arbitraryBlockHash
    <*> arbitraryBlockHash

-- | Arbitrary 'Headers' object with at least one block header.
arbitraryHeaders :: Gen Headers
arbitraryHeaders =
  Headers <$> listOf1 ((,) <$> arbitraryBlockHeader <*> arbitraryVarInt)

-- | Arbitrary 'MerkleBlock' that holds a valid proof: a partial Merkle tree
-- over one to thirty distinct transaction hashes, with any subset of them
-- matching, under a header that has the Merkle root of those hashes. The
-- flags are padded with zero bits to whole bytes, as they are on the wire.
arbitraryMerkleBlock :: Gen MerkleBlock
arbitraryMerkleBlock = do
  bh <- arbitraryBlockHeader
  n <- choose (1, 30)
  hashes <- (TxHash <$> arbitraryHash256) `vectorOfDistinct` n
  matches <- vectorOf n arbitrary
  let (flags, partial) = buildPartialMerkle (zip hashes matches)
      padding = (8 - length flags `mod` 8) `mod` 8
      root = either (const bh.merkle) id (buildMerkleRoot hashes)
  return $
    MerkleBlock
      (bh :: BlockHeader) {merkle = root}
      (fromIntegral n)
      partial
      (flags ++ replicate padding False)
  where
    vectorOfDistinct gen k = go k []
      where
        go 0 acc = return acc
        go i acc = do
          x <- gen `suchThat` (`notElem` acc)
          go (i - 1 :: Int) (x : acc)

-- | Arbitrary 'BlockNode'. One in ten is at height zero, like a genesis
-- node, whose skip hash is its own hash and is not serialized.
arbitraryBlockNode :: Gen BlockNode
arbitraryBlockNode =
  frequency [(1, genesisLike), (9, above)]
  where
    genesisLike = do
      h <- arbitraryBlockHeader
      w <- arbitrarySizedNatural
      return $ BlockNode h 0 w (headerHash h)
    above =
      BlockNode
        <$> arbitraryBlockHeader
        <*> choose (1, maxBound)
        <*> arbitrarySizedNatural
        <*> arbitraryBlockHash

-- | Arbitrary 'HeaderMemory'
arbitraryHeaderMemory :: Gen HeaderMemory
arbitraryHeaderMemory = do
  ls <- listOf $ (,) <$> arbitrary <*> arbitraryBSS
  HeaderMemory (HashMap.fromList ls) <$> arbitraryBlockNode