feat: btclightclient: Abstract the usage of btcd types and store BTCH…

…eaderInfo objects (#58)

proto/babylon/btclightclient/btclightclient.proto

@@ -5,15 +5,6 @@ import "gogoproto/gogo.proto";
 
 option go_package = "github.com/babylonchain/babylon/x/btclightclient/types";
 
-// BaseBTCHeader corresponds to the oldest BTC header maintained in storage
-// It is denoted by the header bytes and the height
-message BaseBTCHeader {
- bytes header = 1 [
- (gogoproto.customtype) = "github.com/babylonchain/babylon/types.BTCHeaderBytes"
- ];
- uint64 height = 2;
-}
-
 message BTCHeaderInfo {
  bytes header = 1 [
  (gogoproto.customtype) = "github.com/babylonchain/babylon/types.BTCHeaderBytes"
@@ -22,5 +13,8 @@ message BTCHeaderInfo {
  (gogoproto.customtype) = "github.com/babylonchain/babylon/types.BTCHeaderHashBytes"
  ];
  uint64 height = 3;
+ bytes work = 4 [
+ (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Uint"
+ ];
 }
 

proto/babylon/btclightclient/genesis.proto

@@ -11,5 +11,5 @@ option go_package = "github.com/babylonchain/babylon/x/btclightclient/types";
 message GenesisState {
  Params params = 1 [(gogoproto.nullable) = false];
 
- BaseBTCHeader base_btc_header = 2 [(gogoproto.nullable) = false];
+ BTCHeaderInfo base_btc_header = 2 [(gogoproto.nullable) = false];
 }

types/btc_header_bytes.go

@@ -134,6 +134,33 @@ func (m *BTCHeaderBytes) FromBlockHeader(header *wire.BlockHeader) {
  }
 }
 
+func (m *BTCHeaderBytes) HasParent(header *BTCHeaderBytes) bool {
+ current := m.ToBlockHeader()
+ parent := header.ToBlockHeader()
+
+ return current.PrevBlock.String() == parent.BlockHash().String()
+}
+
+func (m *BTCHeaderBytes) Eq(other *BTCHeaderBytes) bool {
+ return m.Hash().Eq(other.Hash())
+}
+
+func (m *BTCHeaderBytes) Hash() *BTCHeaderHashBytes {
+ blockHash := m.ToBlockHeader().BlockHash()
+ hashBytes := NewBTCHeaderHashBytesFromChainhash(&blockHash)
+ return &hashBytes
+}
+
+func (m *BTCHeaderBytes) ParentHash() *BTCHeaderHashBytes {
+ parentHash := m.ToBlockHeader().PrevBlock
+ hashBytes := NewBTCHeaderHashBytesFromChainhash(&parentHash)
+ return &hashBytes
+}
+
+func (m *BTCHeaderBytes) Bits() uint32 {
+ return m.ToBlockHeader().Bits
+}
+
 func toBlockHeader(data []byte) (*wire.BlockHeader, error) {
  // Create an empty header
  header := &wire.BlockHeader{}

types/btc_header_bytes_test.go

@@ -202,3 +202,59 @@ func FuzzBTCHeaderBytesBtcdBlockOps(f *testing.F) {
  }
  })
 }
+
+func FuzzBTCHeaderBytesOperators(f *testing.F) {
+ defaultHeader, _ := types.NewBTCHeaderBytesFromHex("00006020c6c5a20e29da938a252c945411eba594cbeba021a1e20000000000000000000039e4bd0cd0b5232bb380a9576fcfe7d8fb043523f7a158187d9473e44c1740e6b4fa7c62ba01091789c24c22")
+ defaultBtcdHeader := defaultHeader.ToBlockHeader()
+
+ f.Add(
+ defaultBtcdHeader.Version,
+ defaultBtcdHeader.Bits,
+ defaultBtcdHeader.Nonce,
+ defaultBtcdHeader.Timestamp.Unix(),
+ defaultBtcdHeader.PrevBlock.String(),
+ defaultBtcdHeader.MerkleRoot.String(),
+ int64(17))
+
+ f.Fuzz(func(t *testing.T, version int32, bits uint32, nonce uint32,
+ timeInt int64, prevBlockStr string, merkleRootStr string, seed int64) {
+
+ rand.Seed(seed)
+ btcdHeader := datagen.GenRandomBtcdHeader(version, bits, nonce, timeInt, prevBlockStr, merkleRootStr)
+
+ btcdHeaderHash := btcdHeader.BlockHash()
+ childPrevBlock := types.NewBTCHeaderHashBytesFromChainhash(&btcdHeaderHash)
+ btcdHeaderChild := datagen.GenRandomBtcdHeader(version, bits, nonce, timeInt, childPrevBlock.MarshalHex(), merkleRootStr)
+
+ var hb, hb2, hbChild types.BTCHeaderBytes
+ hb.FromBlockHeader(btcdHeader)
+ hb2.FromBlockHeader(btcdHeader)
+ hbChild.FromBlockHeader(btcdHeaderChild)
+
+ if !hb.Eq(&hb) {
+ t.Errorf("BTCHeaderBytes object does not equal itself")
+ }
+ if !hb.Eq(&hb2) {
+ t.Errorf("BTCHeaderBytes object does not equal a different object with the same bytes")
+ }
+ if hb.Eq(&hbChild) {
+ t.Errorf("BTCHeaderBytes object equals a different object with different bytes")
+ }
+
+ if !hbChild.HasParent(&hb) {
+ t.Errorf("HasParent method returns false with a correct parent")
+ }
+ if hbChild.HasParent(&hbChild) {
+ t.Errorf("HasParent method returns true for the same object")
+ }
+
+ if !hbChild.ParentHash().Eq(&childPrevBlock) {
+ t.Errorf("ParentHash did not return the parent hash")
+ }
+
+ if !hb.Hash().Eq(&childPrevBlock) {
+ t.Errorf("Hash method does not return the correct hash")
+ }
+
+ })
+}

types/btc_header_hash_bytes.go

@@ -121,6 +121,15 @@ func (m *BTCHeaderHashBytes) FromChainhash(hash *chainhash.Hash) {
  }
 }
 
+func (m *BTCHeaderHashBytes) String() string {
+ return m.ToChainhash().String()
+}
+
+func (m *BTCHeaderHashBytes) Eq(hash *BTCHeaderHashBytes) bool {
+ // TODO: test
+ return m.String() == hash.String()
+}
+
 func toChainhash(data []byte) (*chainhash.Hash, error) {
  return chainhash.NewHash(data)
 }

types/btc_header_hash_bytes_test.go

@@ -198,3 +198,29 @@ func FuzzHeaderHashBytesChainhashOps(f *testing.F) {
  }
  })
 }
+
+func FuzzHeaderHashBytesOperators(f *testing.F) {
+ f.Add(int64(42))
+ f.Fuzz(func(t *testing.T, seed int64) {
+ rand.Seed(seed)
+
+ hexHash := datagen.GenRandomHexStr(types.BTCHeaderHashLen)
+ hexHash2 := datagen.GenRandomHexStr(types.BTCHeaderHashLen)
+ chHash, _ := chainhash.NewHashFromStr(hexHash)
+
+ var hbb, hbb2 types.BTCHeaderHashBytes
+ hbb.FromChainhash(chHash)
+ hbb2, _ = types.NewBTCHeaderHashBytesFromHex(hexHash2)
+
+ if hbb.String() != chHash.String() {
+ t.Errorf("String() method returned %s while %s was expected", hbb, chHash)
+ }
+
+ if !hbb.Eq(&hbb) {
+ t.Errorf("Object does not equal itself")
+ }
+ if hbb.Eq(&hbb2) {
+ t.Errorf("Object %s equals %s", hbb, hbb2)
+ }
+ })
+}

x/btclightclient/client/cli/query.go

@@ -63,7 +63,12 @@ func CmdHashes() *cobra.Command {
 
  queryClient := types.NewQueryClient(clientCtx)
 
- params := types.NewQueryHashesRequest()
+ pageReq, err := client.ReadPageRequest(cmd.Flags())
+ if err != nil {
+ return err
+ }
+
+ params := types.NewQueryHashesRequest(pageReq)
  res, err := queryClient.Hashes(context.Background(), params)
  if err != nil {
  return err
@@ -116,7 +121,12 @@ func CmdMainChain() *cobra.Command {
 
  queryClient := types.NewQueryClient(clientCtx)
 
- params := types.NewQueryMainChainRequest()
+ pageReq, err := client.ReadPageRequest(cmd.Flags())
+ if err != nil {
+ return err
+ }
+
+ params := types.NewQueryMainChainRequest(pageReq)
  res, err := queryClient.MainChain(context.Background(), params)
  if err != nil {
  return err

x/btclightclient/genesis_test.go

@@ -13,10 +13,13 @@ import (
 
 func TestGenesis(t *testing.T) {
  headerBytes, _ := bbl.NewBTCHeaderBytesFromHex(types.DefaultBaseHeaderHex)
+ headerHash := headerBytes.Hash()
+ headerWork := types.CalcWork(&headerBytes)
+ baseHeaderInfo := types.NewBTCHeaderInfo(&headerBytes, headerHash, types.DefaultBaseHeaderHeight, &headerWork)
 
  genesisState := types.GenesisState{
  Params: types.DefaultParams(),
- BaseBtcHeader: types.DefaultBaseBTCHeader(headerBytes, types.DefaultBaseHeaderHeight),
+ BaseBtcHeader: *baseHeaderInfo,
  }
 
  k, ctx := keepertest.BTCLightClientKeeper(t)

x/btclightclient/keeper/base_btc_header.go

@@ -1,45 +1,21 @@
 package keeper
 
 import (
- bbl "github.com/babylonchain/babylon/types"
  "github.com/babylonchain/babylon/x/btclightclient/types"
  sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
-func (k Keeper) GetBaseBTCHeader(ctx sdk.Context) types.BaseBTCHeader {
- baseBtcdHeader := k.HeadersState(ctx).GetBaseBTCHeader()
-
- if baseBtcdHeader == nil {
- return types.BaseBTCHeader{}
- }
-
- baseHash := baseBtcdHeader.BlockHash()
- height, err := k.HeadersState(ctx).GetHeaderHeight(&baseHash)
-
- if err != nil {
- return types.BaseBTCHeader{}
- }
-
- headerBytes := bbl.NewBTCHeaderBytesFromBlockHeader(baseBtcdHeader)
- return types.BaseBTCHeader{Header: &headerBytes, Height: height}
+func (k Keeper) GetBaseBTCHeader(ctx sdk.Context) types.BTCHeaderInfo {
+ baseBtcHeader := k.HeadersState(ctx).GetBaseBTCHeader()
+ return *baseBtcHeader
 }
 
 // SetBaseBTCHeader checks whether a base BTC header exists and
 // if not inserts it into storage
-func (k Keeper) SetBaseBTCHeader(ctx sdk.Context, baseBTCHeader types.BaseBTCHeader) {
+func (k Keeper) SetBaseBTCHeader(ctx sdk.Context, baseBTCHeader types.BTCHeaderInfo) {
  existingHeader := k.HeadersState(ctx).GetBaseBTCHeader()
  if existingHeader != nil {
  panic("A base BTC Header has already been set")
  }
-
- btcdHeader := baseBTCHeader.Header.ToBlockHeader()
-
- // The cumulative work for the Base BTC header is only the work
- // for that particular header. This means that it is very important
- // that no forks will happen that discard the base header because we
- // will not be able to detect those. Cumulative work will build based
- // on the sum of the work of the chain starting from the base header.
- blockWork := types.CalcWork(btcdHeader)
-
- k.HeadersState(ctx).CreateHeader(btcdHeader, baseBTCHeader.Height, blockWork)
+ k.HeadersState(ctx).CreateHeader(&baseBTCHeader)
 }

x/btclightclient/keeper/grpc_query.go

@@ -30,6 +30,14 @@ func (k Keeper) Hashes(ctx context.Context, req *types.QueryHashesRequest) (*typ
 
  sdkCtx := sdk.UnwrapSDKContext(ctx)
 
+ // Ensure that the pagination key corresponds to hash bytes
+ if len(req.Pagination.Key) != 0 {
+ _, err := bbl.NewBTCHeaderHashBytesFromBytes(req.Pagination.Key)
+ if err != nil {
+ return nil, err
+ }
+ }
+
  store := prefix.NewStore(k.HeadersState(sdkCtx).hashToHeight, types.HashToHeightPrefix)
  pageRes, err := query.FilteredPaginate(store, req.Pagination, func(key []byte, _ []byte, accumulate bool) (bool, error) {
  if accumulate {
@@ -50,8 +58,7 @@ func (k Keeper) Contains(ctx context.Context, req *types.QueryContainsRequest) (
  return nil, status.Error(codes.InvalidArgument, "invalid request")
  }
  sdkCtx := sdk.UnwrapSDKContext(ctx)
- chHash := req.Hash.ToChainhash()
- contains := k.HeadersState(sdkCtx).HeaderExists(chHash)
+ contains := k.HeadersState(sdkCtx).HeaderExists(req.Hash)
  return &types.QueryContainsResponse{Contains: contains}, nil
 }
 
@@ -67,19 +74,13 @@ func (k Keeper) MainChain(ctx context.Context, req *types.QueryMainChainRequest)
  }
  // If a starting key has not been set, then the first header is the tip
  prevHeader := k.HeadersState(sdkCtx).GetTip()
- prevHeaderHash := prevHeader.BlockHash()
- prevHeaderHeight, err := k.HeadersState(sdkCtx).GetHeaderHeight(&prevHeaderHash)
- if err != nil {
- panic("Maintained header does not have a height")
- }
  // Otherwise, retrieve the header from the key
  if len(req.Pagination.Key) != 0 {
  headerHash, err := bbl.NewBTCHeaderHashBytesFromBytes(req.Pagination.Key)
  if err != nil {
  return nil, status.Error(codes.InvalidArgument, "key does not correspond to a header hash")
  }
- chHash := headerHash.ToChainhash()
- prevHeader, err = k.HeadersState(sdkCtx).GetHeaderByHash(chHash)
+ prevHeader, err = k.HeadersState(sdkCtx).GetHeaderByHash(&headerHash)
  }
 
  // If no tip exists or a key, then return an empty response
@@ -88,21 +89,18 @@ func (k Keeper) MainChain(ctx context.Context, req *types.QueryMainChainRequest)
  }
 
  var headers []*types.BTCHeaderInfo
- currentHeight := prevHeaderHeight
- headerInfo := types.NewBTCHeaderInfo(prevHeader, prevHeaderHeight)
- headers = append(headers, headerInfo)
+ headers = append(headers, prevHeader)
  store := prefix.NewStore(k.HeadersState(sdkCtx).headers, types.HeadersObjectPrefix)
 
  // Set this value to true to signal to FilteredPaginate to iterate the entries in reverse
  req.Pagination.Reverse = true
  pageRes, err := query.FilteredPaginate(store, req.Pagination, func(_ []byte, value []byte, accumulate bool) (bool, error) {
  if accumulate {
- btcdHeader := blockHeaderFromStoredBytes(value)
+ headerInfo := headerInfoFromStoredBytes(k.cdc, value)
  // If the previous block extends this block, then this block is part of the main chain
- if prevHeader.PrevBlock.String() == btcdHeader.BlockHash().String() {
- currentHeight -= 1
- prevHeader = btcdHeader
- headers = append(headers, types.NewBTCHeaderInfo(btcdHeader, currentHeight))
+ if prevHeader.HasParent(headerInfo) {
+ prevHeader = headerInfo
+ headers = append(headers, headerInfo)
  }
  }
  return true, nil
@@ -114,8 +112,7 @@ func (k Keeper) MainChain(ctx context.Context, req *types.QueryMainChainRequest)
 
  // Override the next key attribute to point to the parent of the last header
  // instead of the next element contained in the store
- prevBlockCh := prevHeader.PrevBlock
- pageRes.NextKey = bbl.NewBTCHeaderHashBytesFromChainhash(&prevBlockCh)
+ pageRes.NextKey = prevHeader.Header.ParentHash().MustMarshal()
 
  return &types.QueryMainChainResponse{Headers: headers, Pagination: pageRes}, nil
 }