datagen: add datagen functions for testing reporter

testutil/datagen/btc_blockchain.go

@@ -0,0 +1,97 @@
+package datagen
+
+import (
+ "math/big"
+ "math/rand"
+
+ "github.com/babylonchain/babylon/btctxformatter"
+ "github.com/btcsuite/btcd/blockchain"
+ "github.com/btcsuite/btcd/chaincfg"
+ "github.com/btcsuite/btcd/chaincfg/chainhash"
+ "github.com/btcsuite/btcd/wire"
+)
+
+func GenRandomBlock(numBabylonTxs int, prevHash *chainhash.Hash) (*wire.MsgBlock, *btctxformatter.RawBtcCheckpoint) {
+ var (
+ randomTxs []*wire.MsgTx
+ rawCkpt *btctxformatter.RawBtcCheckpoint
+ )
+
+ if numBabylonTxs == 2 {
+ randomTxs, rawCkpt = GenRandomBabylonTxPair()
+ } else if numBabylonTxs == 1 {
+ randomTxs, _ = GenRandomBabylonTxPair()
+ randomTxs[1] = GenRandomTx()
+ rawCkpt = nil
+ } else {
+ randomTxs = []*wire.MsgTx{GenRandomTx(), GenRandomTx()}
+ rawCkpt = nil
+ }
+ coinbaseTx := createCoinbaseTx(rand.Int31(), &chaincfg.SimNetParams)
+ msgTxs := []*wire.MsgTx{coinbaseTx}
+ msgTxs = append(msgTxs, randomTxs...)
+
+ // calculate correct Merkle root
+ merkleRoot := calcMerkleRoot(msgTxs)
+ // don't apply any difficulty
+ difficulty, _ := new(big.Int).SetString("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16)
+ workBits := blockchain.BigToCompact(difficulty)
+
+ header := GenRandomBtcdHeader()
+ header.MerkleRoot = merkleRoot
+ header.Bits = workBits
+ if prevHash == nil {
+ header.PrevBlock = chainhash.DoubleHashH(GenRandomByteArray(10))
+ } else {
+ header.PrevBlock = *prevHash
+ }
+ // find a nonce that satisfies difficulty
+ SolveBlock(header)
+
+ block := &wire.MsgBlock{
+ Header: *header,
+ Transactions: msgTxs,
+ }
+ return block, rawCkpt
+}
+
+func GenRandomBlockchainWithBabylonTx(n uint64, partialPercentage float32, fullPercentage float32) ([]*wire.MsgBlock, int, []*btctxformatter.RawBtcCheckpoint) {
+ blocks := []*wire.MsgBlock{}
+ numCkptSegs := 0
+ rawCkpts := []*btctxformatter.RawBtcCheckpoint{}
+ // percentage should be [0, 1]
+ if partialPercentage < 0 || partialPercentage > 1 {
+ return blocks, 0, rawCkpts
+ }
+ if fullPercentage < 0 || fullPercentage > 1 {
+ return blocks, 0, rawCkpts
+ }
+ // n should be > 0
+ if n == 0 {
+ return blocks, 0, rawCkpts
+ }
+
+ // genesis block
+ genesisBlock, rawCkpt := GenRandomBlock(0, nil)
+ blocks = append(blocks, genesisBlock)
+ rawCkpts = append(rawCkpts, rawCkpt)
+
+ // blocks after genesis
+ for i := uint64(1); i < n; i++ {
+ var msgBlock *wire.MsgBlock
+ prevHash := blocks[len(blocks)-1].BlockHash()
+ if rand.Float32() < partialPercentage {
+ msgBlock, rawCkpt = GenRandomBlock(1, &prevHash)
+ numCkptSegs += 1
+ } else if rand.Float32() < partialPercentage+fullPercentage {
+ msgBlock, rawCkpt = GenRandomBlock(2, &prevHash)
+ numCkptSegs += 2
+ } else {
+ msgBlock, rawCkpt = GenRandomBlock(0, &prevHash)
+ }
+
+ blocks = append(blocks, msgBlock)
+ rawCkpts = append(rawCkpts, rawCkpt)
+ }
+ return blocks, numCkptSegs, rawCkpts
+}

testutil/datagen/btc_transaction.go

@@ -9,6 +9,7 @@ import (
  "runtime"
  "time"
 
+ "github.com/babylonchain/babylon/btctxformatter"
  bbn "github.com/babylonchain/babylon/types"
  btcctypes "github.com/babylonchain/babylon/x/btccheckpoint/types"
  "github.com/btcsuite/btcd/blockchain"
@@ -315,11 +316,104 @@ func CreateBlockWithTransaction(
  proof, err := btcctypes.SpvProofFromHeaderAndTransactions(headerBytes.MustMarshal(), txBytes, 1)
 
  if err != nil {
- panic("couldnt calculate prroof")
+ panic("could not calculate proof")
  }
 
  return &BtcHeaderWithProof{
  HeaderBytes: headerBytes,
  SpvProof: proof,
  }
 }
+
+func GenRandomTx() *wire.MsgTx {
+ // structure of the below tx is from https://github.com/btcsuite/btcd/blob/master/wire/msgtx_test.go
+ tx := &wire.MsgTx{
+ Version: 1,
+ TxIn: []*wire.TxIn{
+ {
+ PreviousOutPoint: wire.OutPoint{
+ Hash: chainhash.HashH(GenRandomByteArray(10)),
+ Index: rand.Uint32(),
+ },
+ SignatureScript: GenRandomByteArray(10),
+ Sequence: rand.Uint32(),
+ },
+ },
+ TxOut: []*wire.TxOut{
+ {
+ Value: rand.Int63(),
+ PkScript: GenRandomByteArray(80),
+ },
+ },
+ LockTime: 0,
+ }
+
+ return tx
+}
+
+func GenRandomBabylonTxPair() ([]*wire.MsgTx, *btctxformatter.RawBtcCheckpoint) {
+ txs := []*wire.MsgTx{GenRandomTx(), GenRandomTx()}
+ builder := txscript.NewScriptBuilder()
+
+ // fake a raw checkpoint
+ rawBTCCkpt := GetRandomRawBtcCheckpoint()
+ // encode raw checkpoint to two halves
+ firstHalf, secondHalf, err := btctxformatter.EncodeCheckpointData(
+ btctxformatter.TestTag(48),
+ btctxformatter.CurrentVersion,
+ rawBTCCkpt,
+ )
+ if err != nil {
+ panic(err)
+ }
+
+ dataScript1, err := builder.AddOp(txscript.OP_RETURN).AddData(firstHalf).Script()
+ if err != nil {
+ panic(err)
+ }
+ txs[0].TxOut[0] = wire.NewTxOut(0, dataScript1)
+
+ // reset builder
+ builder = txscript.NewScriptBuilder()
+
+ dataScript2, err := builder.AddOp(txscript.OP_RETURN).AddData(secondHalf).Script()
+ if err != nil {
+ panic(err)
+ }
+ txs[1].TxOut[0] = wire.NewTxOut(0, dataScript2)
+
+ return txs, rawBTCCkpt
+}
+
+func GenRandomBabylonTx() *wire.MsgTx {
+ tx := GenRandomTx()
+ builder := txscript.NewScriptBuilder()
+
+ // fake a raw checkpoint
+ rawBTCCkpt := GetRandomRawBtcCheckpoint()
+ // encode raw checkpoint to two halves
+ firstHalf, secondHalf, err := btctxformatter.EncodeCheckpointData(
+ btctxformatter.TestTag(48),
+ btctxformatter.CurrentVersion,
+ rawBTCCkpt,
+ )
+ if err != nil {
+ panic(err)
+ }
+ idx := rand.Intn(2)
+ if idx == 0 {
+ dataScript, err := builder.AddOp(txscript.OP_RETURN).AddData(firstHalf).Script()
+ if err != nil {
+ panic(err)
+ }
+ tx.TxOut[0] = wire.NewTxOut(0, dataScript)
+ } else {
+ dataScript, err := builder.AddOp(txscript.OP_RETURN).AddData(secondHalf).Script()
+ if err != nil {
+ panic(err)
+ }
+ tx.TxOut[0] = wire.NewTxOut(0, dataScript)
+ }
+
+ return tx
+}

testutil/datagen/raw_checkpoint.go

@@ -1,12 +1,25 @@
 package datagen
 
 import (
+ "math/rand"
+
+ "github.com/babylonchain/babylon/btctxformatter"
  "github.com/babylonchain/babylon/crypto/bls12381"
  "github.com/babylonchain/babylon/x/checkpointing/types"
  "github.com/boljen/go-bitmap"
- "math/rand"
 )
 
+func GetRandomRawBtcCheckpoint() *btctxformatter.RawBtcCheckpoint {
+ rawCkpt := GenRandomRawCheckpoint()
+ return &btctxformatter.RawBtcCheckpoint{
+ Epoch: rawCkpt.EpochNum,
+ LastCommitHash: *rawCkpt.LastCommitHash,
+ BitMap: rawCkpt.Bitmap,
+ SubmitterAddress: GenRandomByteArray(btctxformatter.AddressLength),
+ BlsSig: rawCkpt.BlsMultiSig.Bytes(),
+ }
+}
+
 func GenRandomRawCheckpointWithMeta() *types.RawCheckpointWithMeta {
  ckptWithMeta := &types.RawCheckpointWithMeta{
  Ckpt: GenRandomRawCheckpoint(),