feat: add e2e-init-chain (#46)

Add e2e-init-chain, it is necessary for e2e testing in new releases to
have the init chain with the same proto versions used at the v09 bin

Makefile

@@ -243,7 +243,7 @@ endif
 
 .PHONY: run-tests test test-all $(TEST_TARGETS)
 
-test-e2e: build-docker
+test-e2e: build-docker-e2e
  go test -mod=readonly -timeout=25m -v $(PACKAGES_E2E) -count=1 --tags=e2e
 
 test-sim-nondeterminism:
@@ -408,17 +408,32 @@ proto-lint: ## Lint protobuf files
 
 .PHONY: proto-gen proto-swagger-gen proto-format prot-lint
 
+###############################################################################
+### E2E build ###
+###############################################################################
+
+# Executed to build the binary for chain initialization, one of
+## chain => test/e2e/initialization/chain/main.go
+## node => test/e2e/initialization/node/main.go
+e2e-build-script:
+ mkdir -p $(BUILDDIR)
+ go build -mod=readonly $(BUILD_FLAGS) -o $(BUILDDIR)/ ./test/e2e/initialization/$(E2E_SCRIPT_NAME)
+
 ###############################################################################
 ### Docker ###
 ###############################################################################
 
 build-docker: ## Build babylond Docker image
  $(MAKE) -C contrib/images babylond
 
+build-docker-e2e:
+ $(MAKE) -C contrib/images babylond-e2e
+ $(MAKE) -C contrib/images e2e-init-chain
+
 build-cosmos-relayer-docker: ## Build Docker image for the Cosmos relayer
  $(MAKE) -C contrib/images cosmos-relayer
 
-.PHONY: build-docker build-cosmos-relayer-docker
+.PHONY: build-docker build-docker-e2e build-cosmos-relayer-docker
 
 ###############################################################################
 ### Localnet ###

contrib/images/Makefile

@@ -1,20 +1,31 @@
 RELAYER_TAG := $(shell grep '^ENV RELAYER_TAG' cosmos-relayer/Dockerfile | cut -f3 -d\ )
+BABYLON_FULL_PATH := $(shell git rev-parse --show-toplevel)
 
 all: babylond cosmos-relayer
 
 babylond: babylond-rmi
- docker build --tag babylonlabs-io/babylond -f babylond/Dockerfile \
- $(shell git rev-parse --show-toplevel)
+ docker build --tag babylonlabs-io/babylond -f babylond/Dockerfile ${BABYLON_FULL_PATH}
+
+babylond-e2e:
+ docker build --tag babylonlabs-io/babylond -f babylond/Dockerfile ${BABYLON_FULL_PATH} \
+ --build-arg BUILD_TAGS="e2e"
 
 babylond-rmi:
  docker rmi babylonlabs-io/babylond 2>/dev/null; true
 
+e2e-init-chain-rmi:
+ docker rmi babylonlabs-io/babylond-e2e-init-chain --force 2>/dev/null; true
+
+e2e-init-chain:
+ docker build -t babylonlabs-io/babylond-e2e-init-chain --build-arg E2E_SCRIPT_NAME=chain \
+ -f e2e-initialization/init.Dockerfile ${BABYLON_FULL_PATH}
+
 cosmos-relayer: cosmos-relayer-rmi
  docker build --tag babylonlabs-io/cosmos-relayer:${RELAYER_TAG} -f cosmos-relayer/Dockerfile \
-  $(shell git rev-parse --show-toplevel)/contrib/images/cosmos-relayer
+ ${BABYLON_FULL_PATH}/contrib/images/cosmos-relayer
  docker tag babylonlabs-io/cosmos-relayer:${RELAYER_TAG} babylonlabs-io/cosmos-relayer:latest
 
 cosmos-relayer-rmi:
  docker rmi babylonlabs-io/cosmos-relayer 2>/dev/null; true
 
-.PHONY: all babylond cosmos-relayer babylond-rmi cosmos-relayer-rmi
+.PHONY: all babylond cosmos-relayer babylond-e2e e2e-init-chain e2e-init-chain-rmi babylond-rmi cosmos-relayer-rmi

contrib/images/e2e-initialization/init.Dockerfile

@@ -0,0 +1,46 @@
+FROM golang:1.21 as build-env
+
+ARG E2E_SCRIPT_NAME
+# Version to build. Default is empty
+ARG VERSION
+
+# Copy All
+WORKDIR /go/src/github.com/babylonlabs-io/babylon
+COPY ./ /go/src/github.com/babylonlabs-io/babylon/
+
+# If version is set, then checkout this version
+RUN if [ -n "${VERSION}" ]; then \
+ git checkout -f ${VERSION}; \
+ fi
+
+RUN LEDGER_ENABLED=false LINK_STATICALLY=false E2E_SCRIPT_NAME=${E2E_SCRIPT_NAME} make e2e-build-script
+
+FROM debian:bookworm-slim AS wasm-link
+
+RUN apt-get update && apt-get install -y wget bash
+
+# Label should match your github repo
+LABEL org.opencontainers.image.source="https://github.com/babylonlabs-io/babylond:${VERSION}"
+
+# Install libraries
+# Cosmwasm - Download correct libwasmvm version
+COPY --from=build-env /go/src/github.com/babylonlabs-io/babylon/go.mod /tmp
+RUN WASMVM_VERSION=$(grep github.com/CosmWasm/wasmvm /tmp/go.mod | cut -d' ' -f2) && \
+ wget https://github.com/CosmWasm/wasmvm/releases/download/$WASMVM_VERSION/libwasmvm.$(uname -m).so \
+ -O /lib/libwasmvm.$(uname -m).so && \
+ # verify checksum
+ wget https://github.com/CosmWasm/wasmvm/releases/download/$WASMVM_VERSION/checksums.txt -O /tmp/checksums.txt && \
+ sha256sum /lib/libwasmvm.$(uname -m).so | grep $(cat /tmp/checksums.txt | grep libwasmvm.$(uname -m) | cut -d ' ' -f 1)
+RUN rm -f /tmp/go.mod
+
+# Args only last for a single build stage - renew
+ARG E2E_SCRIPT_NAME
+
+COPY --from=build-env /go/src/github.com/babylonlabs-io/babylon/build/${E2E_SCRIPT_NAME} /bin/${E2E_SCRIPT_NAME}
+
+# Docker ARGs are not expanded in ENTRYPOINT in the exec mode. At the same time,
+# it is impossible to add CMD arguments when running a container in the shell mode.
+# As a workaround, we create the entrypoint.sh script to bypass these issues.
+RUN echo "#!/bin/bash\n${E2E_SCRIPT_NAME} \"\$@\"" >> entrypoint.sh && chmod +x entrypoint.sh
+
+ENTRYPOINT ["./entrypoint.sh"]

test/e2e/btc_staking_e2e_test.go

@@ -297,12 +297,12 @@ func (s *BTCStakingTestSuite) Test3CommitPublicRandomnessAndSubmitFinalitySignat
  s.Equal(prCommitMap[activatedHeight].Commitment, msgCommitPubRandList.Commitment)
 
  // no reward gauge for finality provider and delegation yet
- fpBabylonAddr := sdk.AccAddress(nonValidatorNode.SecretKey.PubKey().Address().Bytes())
+ fpBabylonAddr, err := sdk.AccAddressFromBech32(cacheFP.Addr)
+ s.NoError(err)
+
  _, err = nonValidatorNode.QueryRewardGauge(fpBabylonAddr)
- s.Error(err)
- delBabylonAddr := sdk.AccAddress(nonValidatorNode.SecretKey.PubKey().Address().Bytes())
- _, err = nonValidatorNode.QueryRewardGauge(delBabylonAddr)
- s.Error(err)
+ s.ErrorContains(err, itypes.ErrRewardGaugeNotFound.Error())
+ delBabylonAddr := fpBabylonAddr
 
  /*
  submit finality signature
@@ -358,8 +358,10 @@ func (s *BTCStakingTestSuite) Test4WithdrawReward() {
  s.NoError(err)
 
  // finality provider balance before withdraw
- fpBabylonAddr := sdk.AccAddress(nonValidatorNode.SecretKey.PubKey().Address().Bytes())
- delBabylonAddr := sdk.AccAddress(nonValidatorNode.SecretKey.PubKey().Address().Bytes())
+ fpBabylonAddr, err := sdk.AccAddressFromBech32(cacheFP.Addr)
+ s.NoError(err)
+ delBabylonAddr := fpBabylonAddr
+
  fpBalance, err := nonValidatorNode.QueryBalances(fpBabylonAddr.String())
  s.NoError(err)
  // finality provider reward gauge should not be fully withdrawn

test/e2e/btc_timestamping_e2e_test.go

@@ -38,7 +38,6 @@ func (s *BTCTimestampingTestSuite) SetupSuite() {
  // 3. Run IBC relayer between the two chains.
  // 4. Execute various e2e tests, including IBC
  s.configurer, err = configurer.NewBTCTimestampingConfigurer(s.T(), true)
-
  s.Require().NoError(err)
 
  err = s.configurer.ConfigureChains()
@@ -50,7 +49,9 @@ func (s *BTCTimestampingTestSuite) SetupSuite() {
 
 func (s *BTCTimestampingTestSuite) TearDownSuite() {
  err := s.configurer.ClearResources()
- s.Require().NoError(err)
+ if err != nil {
+ s.T().Logf("error to clear resources %s", err.Error())
+ }
 }
 
 // Most simple test, just checking that two chains are up and connected through

test/e2e/configurer/chain/chain.go

@@ -1,18 +1,22 @@
 package chain
 
 import (
+ "encoding/hex"
  "fmt"
- ibctesting "github.com/cosmos/ibc-go/v8/testing"
+ "strings"
  "testing"
  "time"
 
+ ibctesting "github.com/cosmos/ibc-go/v8/testing"
+
  coretypes "github.com/cometbft/cometbft/rpc/core/types"
  sdk "github.com/cosmos/cosmos-sdk/types"
  "github.com/stretchr/testify/require"
 
  "github.com/babylonlabs-io/babylon/test/e2e/configurer/config"
  "github.com/babylonlabs-io/babylon/test/e2e/containers"
  "github.com/babylonlabs-io/babylon/test/e2e/initialization"
+ btclighttypes "github.com/babylonlabs-io/babylon/x/btclightclient/types"
 )
 
 type Config struct {
@@ -27,6 +31,7 @@ type Config struct {
  LatestProposalNumber int
  LatestLockNumber int
  NodeConfigs []*NodeConfig
+ BTCHeaders []*btclighttypes.BTCHeaderInfo
  IBCConfig *ibctesting.ChannelConfig
 
  LatestCodeId int
@@ -57,6 +62,7 @@ func New(t *testing.T, containerManager *containers.Manager, id string, initVali
  ExpeditedVotingPeriod: config.PropDepositBlocks + numVal*config.PropVoteBlocks + config.PropBufferBlocks - 2,
  t: t,
  containerManager: containerManager,
+ BTCHeaders: []*btclighttypes.BTCHeaderInfo{},
  }
 }
 
@@ -173,3 +179,20 @@ func (c *Config) GetNodeAtIndex(nodeIndex int) (*NodeConfig, error) {
  }
  return c.NodeConfigs[nodeIndex], nil
 }
+
+// BTCHeaderBytesHexJoined join all the btc headers as byte string hex
+func (c *Config) BTCHeaderBytesHexJoined() string {
+ if c.BTCHeaders == nil || len(c.BTCHeaders) == 0 {
+ return ""
+ }
+
+ strBtcHeaders := make([]string, len(c.BTCHeaders))
+ for i, btcHeader := range c.BTCHeaders {
+ bz, err := btcHeader.Marshal()
+ if err != nil {
+ panic(err)
+ }
+ strBtcHeaders[i] = hex.EncodeToString(bz)
+ }
+ return strings.Join(strBtcHeaders, ",")
+}

test/e2e/configurer/chain/queries.go

@@ -243,14 +243,14 @@ func (n *NodeConfig) QueryHeaderDepth(hash string) (uint64, error) {
  return blcResponse.Depth, nil
 }
 
-func (n *NodeConfig) QueryListHeaders(chainID string, pagination *query.PageRequest) (*zctypes.QueryListHeadersResponse, error) {
+func (n *NodeConfig) QueryListHeaders(consumerID string, pagination *query.PageRequest) (*zctypes.QueryListHeadersResponse, error) {
  queryParams := url.Values{}
  if pagination != nil {
  queryParams.Set("pagination.key", base64.URLEncoding.EncodeToString(pagination.Key))
  queryParams.Set("pagination.limit", strconv.Itoa(int(pagination.Limit)))
  }
 
- path := fmt.Sprintf("babylon/zoneconcierge/v1/headers/%s", chainID)
+ path := fmt.Sprintf("babylon/zoneconcierge/v1/headers/%s", consumerID)
  bz, err := n.QueryGRPCGateway(path, queryParams)
  require.NoError(n.t, err)
 
@@ -262,10 +262,10 @@ func (n *NodeConfig) QueryListHeaders(chainID string, pagination *query.PageRequ
  return &resp, nil
 }
 
-func (n *NodeConfig) QueryFinalizedChainsInfo(chainIDs []string) ([]*zctypes.FinalizedChainInfo, error) {
+func (n *NodeConfig) QueryFinalizedChainsInfo(consumerIDs []string) ([]*zctypes.FinalizedChainInfo, error) {
  queryParams := url.Values{}
- for _, chainId := range chainIDs {
- queryParams.Add("chain_ids", chainId)
+ for _, consumerID := range consumerIDs {
+ queryParams.Add("chain_ids", consumerID)
  }
 
  bz, err := n.QueryGRPCGateway("babylon/zoneconcierge/v1/finalized_chains_info", queryParams)
@@ -279,11 +279,11 @@ func (n *NodeConfig) QueryFinalizedChainsInfo(chainIDs []string) ([]*zctypes.Fin
  return resp.FinalizedChainsInfo, nil
 }
 
-func (n *NodeConfig) QueryEpochChainsInfo(epochNum uint64, chainIDs []string) ([]*zctypes.ChainInfo, error) {
+func (n *NodeConfig) QueryEpochChainsInfo(epochNum uint64, consumerIDs []string) ([]*zctypes.ChainInfo, error) {
  queryParams := url.Values{}
- for _, chainId := range chainIDs {
+ for _, consumerID := range consumerIDs {
  queryParams.Add("epoch_num", fmt.Sprintf("%d", epochNum))
- queryParams.Add("chain_ids", chainId)
+ queryParams.Add("chain_ids", consumerID)
  }
 
  bz, err := n.QueryGRPCGateway("babylon/zoneconcierge/v1/epoch_chains_info", queryParams)
@@ -307,10 +307,10 @@ func (n *NodeConfig) QueryChains() (*[]string, error) {
  return &chainsResponse.ChainIds, nil
 }
 
-func (n *NodeConfig) QueryChainsInfo(chainIDs []string) ([]*zctypes.ChainInfo, error) {
+func (n *NodeConfig) QueryChainsInfo(consumerIDs []string) ([]*zctypes.ChainInfo, error) {
  queryParams := url.Values{}
- for _, chainId := range chainIDs {
- queryParams.Add("chain_ids", chainId)
+ for _, consumerId := range consumerIDs {
+ queryParams.Add("chain_ids", consumerId)
  }
 
  bz, err := n.QueryGRPCGateway("/babylon/zoneconcierge/v1/chains_info", queryParams)

test/e2e/configurer/current.go

@@ -51,7 +51,10 @@ func (cb *CurrentBranchConfigurer) ConfigureChain(chainConfig *chain.Config) err
  tmpDir,
  chainConfig.ValidatorInitConfigs,
  time.Duration(chainConfig.VotingPeriod*1000000000),
- time.Duration(chainConfig.ExpeditedVotingPeriod*1000000000), 0)
+ time.Duration(chainConfig.ExpeditedVotingPeriod*1000000000),
+ 0,
+ chainConfig.BTCHeaders,
+ )
  if err != nil {
  return err
  }

test/e2e/initialization/chain/main.go

@@ -1,13 +1,16 @@
 package main
 
 import (
+ "encoding/hex"
  "encoding/json"
  "flag"
  "fmt"
  "os"
+ "strings"
  "time"
 
  "github.com/babylonlabs-io/babylon/test/e2e/initialization"
+ btclighttypes "github.com/babylonlabs-io/babylon/x/btclightclient/types"
 )
 
 func main() {
@@ -16,6 +19,7 @@ func main() {
  dataDir string
  chainId string
  config string
+ btcHeadersBytesHexStr string
  votingPeriod time.Duration
  expeditedVotingPeriod time.Duration
  forkHeight int
@@ -24,6 +28,7 @@ func main() {
  flag.StringVar(&dataDir, "data-dir", "", "chain data directory")
  flag.StringVar(&chainId, "chain-id", "", "chain ID")
  flag.StringVar(&config, "config", "", "serialized config")
+ flag.StringVar(&btcHeadersBytesHexStr, "btc-headers", "", "btc header bytes comma separated")
  flag.DurationVar(&votingPeriod, "voting-period", 30000000000, "voting period")
  flag.DurationVar(&expeditedVotingPeriod, "expedited-voting-period", 20000000000, "expedited voting period")
  flag.IntVar(&forkHeight, "fork-height", 0, "fork height")
@@ -43,7 +48,8 @@ func main() {
  panic(err)
  }
 
- createdChain, err := initialization.InitChain(chainId, dataDir, valConfig, votingPeriod, expeditedVotingPeriod, forkHeight)
+ btcHeaders := btcHeaderFromFlag(btcHeadersBytesHexStr)
+ createdChain, err := initialization.InitChain(chainId, dataDir, valConfig, votingPeriod, expeditedVotingPeriod, forkHeight, btcHeaders)
  if err != nil {
  panic(err)
  }
@@ -54,3 +60,27 @@ func main() {
  panic(err)
  }
 }
+
+func btcHeaderFromFlag(btcHeadersBytesHexStr string) []*btclighttypes.BTCHeaderInfo {
+ btcHeaders := []*btclighttypes.BTCHeaderInfo{}
+ if len(btcHeadersBytesHexStr) == 0 {
+ return btcHeaders
+ }
+
+ btcHeadersBytesHex := strings.Split(btcHeadersBytesHexStr, ",")
+ for _, btcHeaderBytesHex := range btcHeadersBytesHex {
+ btcHeaderBytes, err := hex.DecodeString(btcHeaderBytesHex)
+ if err != nil {
+ panic(err)
+ }
+
+ btcHeader := &btclighttypes.BTCHeaderInfo{}
+ err = btcHeader.Unmarshal(btcHeaderBytes)
+ if err != nil {
+ panic(err)
+ }
+
+ btcHeaders = append(btcHeaders, btcHeader)
+ }
+ return btcHeaders
+}