feat(zetaclient): converge AppContext with ZetaCoreContext

changelog.md

@@ -55,6 +55,7 @@
 * [2357](https://github.com/zeta-chain/node/pull/2357) - integrate base Signer structure into EVM/Bitcoin Signer
 * [2359](https://github.com/zeta-chain/node/pull/2359) - integrate base Observer structure into EVM/Bitcoin Observer
 * [2375](https://github.com/zeta-chain/node/pull/2375) - improve & speedup code formatting
+* [2395](https://github.com/zeta-chain/node/pull/2395) - converge AppContext with ZetaCoreContext in zetaclient
 
 ### Tests
 

cmd/zetaclientd/debug.go

@@ -11,6 +11,7 @@ import (
 	ethcommon "github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/onrik/ethrpc"
+	"github.com/rs/zerolog"
 	"github.com/spf13/cobra"
 
 	"github.com/zeta-chain/zetacore/pkg/chains"
@@ -42,163 +43,166 @@ func init() {
 }
 
 func DebugCmd() *cobra.Command {
-	cmd := &cobra.Command{
+	return &cobra.Command{
 		Use:   "get-inbound-ballot [inboundHash] [chainID]",
 		Short: "provide txHash and chainID to get the ballot status for the txHash",
-		RunE: func(_ *cobra.Command, args []string) error {
-			cobra.ExactArgs(2)
-			cfg, err := config.Load(debugArgs.zetaCoreHome)
-			if err != nil {
-				return err
-			}
-			coreContext := clientcontext.NewZetacoreContext(cfg)
-			chainID, err := strconv.ParseInt(args[1], 10, 64)
-			if err != nil {
-				return err
-			}
-			inboundHash := args[0]
-			var ballotIdentifier string
-
-			// create a new zetacore client
-			client, err := zetacore.NewClient(
-				&keys.Keys{OperatorAddress: sdk.MustAccAddressFromBech32(sample.AccAddress())},
-				debugArgs.zetaNode,
-				"",
-				debugArgs.zetaChainID,
-				false,
-				nil)
-			if err != nil {
-				return err
-			}
-			chainParams, err := client.GetChainParams()
-			if err != nil {
-				return err
-			}
-			tssEthAddress, err := client.GetEthTssAddress()
-			if err != nil {
-				return err
-			}
-			chain := chains.GetChainFromChainID(chainID)
-			if chain == nil {
-				return fmt.Errorf("invalid chain id")
-			}
+		RunE:  debugCmd,
+	}
+}
 
-			// get ballot identifier according to the chain type
-			if chains.IsEVMChain(chain.ChainId) {
-				evmObserver := evmobserver.Observer{}
-				evmObserver.WithZetacoreClient(client)
-				var ethRPC *ethrpc.EthRPC
-				var client *ethclient.Client
-				coinType := coin.CoinType_Cmd
-				for chain, evmConfig := range cfg.GetAllEVMConfigs() {
-					if chainID == chain {
-						ethRPC = ethrpc.NewEthRPC(evmConfig.Endpoint)
-						client, err = ethclient.Dial(evmConfig.Endpoint)
-						if err != nil {
-							return err
-						}
-						evmObserver.WithEvmClient(client)
-						evmObserver.WithEvmJSONRPC(ethRPC)
-						evmObserver.WithChain(*chains.GetChainFromChainID(chainID))
-					}
-				}
-				hash := ethcommon.HexToHash(inboundHash)
-				tx, isPending, err := evmObserver.TransactionByHash(inboundHash)
-				if err != nil {
-					return fmt.Errorf("tx not found on chain %s , %d", err.Error(), chain.ChainId)
-				}
-				if isPending {
-					return fmt.Errorf("tx is still pending")
-				}
-				receipt, err := client.TransactionReceipt(context.Background(), hash)
-				if err != nil {
-					return fmt.Errorf("tx receipt not found on chain %s, %d", err.Error(), chain.ChainId)
-				}
+func debugCmd(_ *cobra.Command, args []string) error {
+	cobra.ExactArgs(2)
+	cfg, err := config.Load(debugArgs.zetaCoreHome)
+	if err != nil {
+		return err
+	}
 
-				for _, chainParams := range chainParams {
-					if chainParams.ChainId == chainID {
-						evmObserver.SetChainParams(observertypes.ChainParams{
-							ChainId:                     chainID,
-							ConnectorContractAddress:    chainParams.ConnectorContractAddress,
-							ZetaTokenContractAddress:    chainParams.ZetaTokenContractAddress,
-							Erc20CustodyContractAddress: chainParams.Erc20CustodyContractAddress,
-						})
-						evmChainParams, found := coreContext.GetEVMChainParams(chainID)
-						if !found {
-							return fmt.Errorf("missing chain params for chain %d", chainID)
-						}
-						evmChainParams.ZetaTokenContractAddress = chainParams.ZetaTokenContractAddress
-						if strings.EqualFold(tx.To, chainParams.ConnectorContractAddress) {
-							coinType = coin.CoinType_Zeta
-						} else if strings.EqualFold(tx.To, chainParams.Erc20CustodyContractAddress) {
-							coinType = coin.CoinType_ERC20
-						} else if strings.EqualFold(tx.To, tssEthAddress) {
-							coinType = coin.CoinType_Gas
-						}
-					}
-				}
+	appContext := clientcontext.New(cfg, zerolog.Nop())
 
-				switch coinType {
-				case coin.CoinType_Zeta:
-					ballotIdentifier, err = evmObserver.CheckAndVoteInboundTokenZeta(tx, receipt, false)
-					if err != nil {
-						return err
-					}
-
-				case coin.CoinType_ERC20:
-					ballotIdentifier, err = evmObserver.CheckAndVoteInboundTokenERC20(tx, receipt, false)
-					if err != nil {
-						return err
-					}
-
-				case coin.CoinType_Gas:
-					ballotIdentifier, err = evmObserver.CheckAndVoteInboundTokenGas(tx, receipt, false)
-					if err != nil {
-						return err
-					}
-				default:
-					fmt.Println("CoinType not detected")
-				}
-				fmt.Println("CoinType : ", coinType)
-			} else if chains.IsBitcoinChain(chain.ChainId) {
-				btcObserver := btcobserver.Observer{}
-				btcObserver.WithZetacoreClient(client)
-				btcObserver.WithChain(*chains.GetChainFromChainID(chainID))
-				connCfg := &rpcclient.ConnConfig{
-					Host:         cfg.BitcoinConfig.RPCHost,
-					User:         cfg.BitcoinConfig.RPCUsername,
-					Pass:         cfg.BitcoinConfig.RPCPassword,
-					HTTPPostMode: true,
-					DisableTLS:   true,
-					Params:       cfg.BitcoinConfig.RPCParams,
-				}
+	chainID, err := strconv.ParseInt(args[1], 10, 64)
+	if err != nil {
+		return err
+	}
+
+	inboundHash := args[0]
+	var ballotIdentifier string
+
+	// create a new zetacore client
+	client, err := zetacore.NewClient(
+		&keys.Keys{OperatorAddress: sdk.MustAccAddressFromBech32(sample.AccAddress())},
+		debugArgs.zetaNode,
+		"",
+		debugArgs.zetaChainID,
+		false,
+		nil)
+	if err != nil {
+		return err
+	}
+	chainParams, err := client.GetChainParams()
+	if err != nil {
+		return err
+	}
+	tssEthAddress, err := client.GetEthTssAddress()
+	if err != nil {
+		return err
+	}
+	chain := chains.GetChainFromChainID(chainID)
+	if chain == nil {
+		return fmt.Errorf("invalid chain id")
+	}
 
-				btcClient, err := rpcclient.New(connCfg, nil)
+	// get ballot identifier according to the chain type
+	if chains.IsEVMChain(chain.ChainId) {
+		evmObserver := evmobserver.Observer{}
+		evmObserver.WithZetacoreClient(client)
+		var ethRPC *ethrpc.EthRPC
+		var client *ethclient.Client
+		coinType := coin.CoinType_Cmd
+		for chain, evmConfig := range cfg.GetAllEVMConfigs() {
+			if chainID == chain {
+				ethRPC = ethrpc.NewEthRPC(evmConfig.Endpoint)
+				client, err = ethclient.Dial(evmConfig.Endpoint)
 				if err != nil {
 					return err
 				}
-				btcObserver.WithBtcClient(btcClient)
-				ballotIdentifier, err = btcObserver.CheckReceiptForBtcTxHash(inboundHash, false)
-				if err != nil {
-					return err
+				evmObserver.WithEvmClient(client)
+				evmObserver.WithEvmJSONRPC(ethRPC)
+				evmObserver.WithChain(*chains.GetChainFromChainID(chainID))
+			}
+		}
+		hash := ethcommon.HexToHash(inboundHash)
+		tx, isPending, err := evmObserver.TransactionByHash(inboundHash)
+		if err != nil {
+			return fmt.Errorf("tx not found on chain %s , %d", err.Error(), chain.ChainId)
+		}
+		if isPending {
+			return fmt.Errorf("tx is still pending")
+		}
+		receipt, err := client.TransactionReceipt(context.Background(), hash)
+		if err != nil {
+			return fmt.Errorf("tx receipt not found on chain %s, %d", err.Error(), chain.ChainId)
+		}
+
+		for _, chainParams := range chainParams {
+			if chainParams.ChainId == chainID {
+				evmObserver.SetChainParams(observertypes.ChainParams{
+					ChainId:                     chainID,
+					ConnectorContractAddress:    chainParams.ConnectorContractAddress,
+					ZetaTokenContractAddress:    chainParams.ZetaTokenContractAddress,
+					Erc20CustodyContractAddress: chainParams.Erc20CustodyContractAddress,
+				})
+				evmChainParams, found := appContext.GetEVMChainParams(chainID)
+				if !found {
+					return fmt.Errorf("missing chain params for chain %d", chainID)
+				}
+				evmChainParams.ZetaTokenContractAddress = chainParams.ZetaTokenContractAddress
+				if strings.EqualFold(tx.To, chainParams.ConnectorContractAddress) {
+					coinType = coin.CoinType_Zeta
+				} else if strings.EqualFold(tx.To, chainParams.Erc20CustodyContractAddress) {
+					coinType = coin.CoinType_ERC20
+				} else if strings.EqualFold(tx.To, tssEthAddress) {
+					coinType = coin.CoinType_Gas
 				}
 			}
-			fmt.Println("BallotIdentifier : ", ballotIdentifier)
+		}
 
-			// query ballot
-			ballot, err := client.GetBallot(ballotIdentifier)
+		switch coinType {
+		case coin.CoinType_Zeta:
+			ballotIdentifier, err = evmObserver.CheckAndVoteInboundTokenZeta(tx, receipt, false)
 			if err != nil {
 				return err
 			}
 
-			for _, vote := range ballot.Voters {
-				fmt.Printf("%s : %s \n", vote.VoterAddress, vote.VoteType)
+		case coin.CoinType_ERC20:
+			ballotIdentifier, err = evmObserver.CheckAndVoteInboundTokenERC20(tx, receipt, false)
+			if err != nil {
+				return err
 			}
-			fmt.Println("BallotStatus : ", ballot.BallotStatus)
 
-			return nil
-		},
+		case coin.CoinType_Gas:
+			ballotIdentifier, err = evmObserver.CheckAndVoteInboundTokenGas(tx, receipt, false)
+			if err != nil {
+				return err
+			}
+		default:
+			fmt.Println("CoinType not detected")
+		}
+		fmt.Println("CoinType : ", coinType)
+	} else if chains.IsBitcoinChain(chain.ChainId) {
+		btcObserver := btcobserver.Observer{}
+		btcObserver.WithZetacoreClient(client)
+		btcObserver.WithChain(*chains.GetChainFromChainID(chainID))
+		connCfg := &rpcclient.ConnConfig{
+			Host:         cfg.BitcoinConfig.RPCHost,
+			User:         cfg.BitcoinConfig.RPCUsername,
+			Pass:         cfg.BitcoinConfig.RPCPassword,
+			HTTPPostMode: true,
+			DisableTLS:   true,
+			Params:       cfg.BitcoinConfig.RPCParams,
+		}
+
+		btcClient, err := rpcclient.New(connCfg, nil)
+		if err != nil {
+			return err
+		}
+		btcObserver.WithBtcClient(btcClient)
+		ballotIdentifier, err = btcObserver.CheckReceiptForBtcTxHash(inboundHash, false)
+		if err != nil {
+			return err
+		}
+	}
+	fmt.Println("BallotIdentifier : ", ballotIdentifier)
+
+	// query ballot
+	ballot, err := client.GetBallot(ballotIdentifier)
+	if err != nil {
+		return err
+	}
+
+	for _, vote := range ballot.Voters {
+		fmt.Printf("%s : %s \n", vote.VoterAddress, vote.VoteType)
 	}
+	fmt.Println("BallotStatus : ", ballot.BallotStatus)
 
-	return cmd
+	return nil
 }

cmd/zetaclientd/keygen_tss.go

@@ -74,7 +74,7 @@ func GenerateTss(
 		// This loop will try keygen at the keygen block and then wait for keygen to be successfully reported by all nodes before breaking out of the loop.
 		// If keygen is unsuccessful, it will reset the triedKeygenAtBlock flag and try again at a new keygen block.
 
-		keyGen := appContext.ZetacoreContext().GetKeygen()
+		keyGen := appContext.GetKeygen()
 		if keyGen.Status == observertypes.KeygenStatus_KeyGenSuccess {
 			return tss, nil
 		}

cmd/zetaclientd/start.go

@@ -144,8 +144,8 @@ func start(_ *cobra.Command, _ []string) error {
 	startLogger.Debug().Msgf("CreateAuthzSigner is ready")
 
 	// Initialize core parameters from zetacore
-	appContext := context.NewAppContext(context.NewZetacoreContext(cfg), cfg)
-	err = zetacoreClient.UpdateZetacoreContext(appContext.ZetacoreContext(), true, startLogger)
+	appContext := context.New(cfg, masterLogger)
+	err = zetacoreClient.UpdateZetacoreContext(appContext, true, startLogger)
 	if err != nil {
 		startLogger.Error().Err(err).Msg("Error getting core parameters")
 		return err
@@ -226,7 +226,7 @@ func start(_ *cobra.Command, _ []string) error {
 	// For existing keygen, this should directly proceed to the next step
 	ticker := time.NewTicker(time.Second * 1)
 	for range ticker.C {
-		keyGen := appContext.ZetacoreContext().GetKeygen()
+		keyGen := appContext.GetKeygen()
 		if keyGen.Status != observerTypes.KeygenStatus_KeyGenSuccess {
 			startLogger.Info().Msgf("Waiting for TSS Keygen to be a success, current status %s", keyGen.Status)
 			continue
@@ -250,7 +250,7 @@ func start(_ *cobra.Command, _ []string) error {
 	}
 	startLogger.Info().
 		Msgf("Current TSS address \n ETH : %s \n BTC : %s \n PubKey : %s ", tss.EVMAddress(), tss.BTCAddress(), tss.CurrentPubkey)
-	if len(appContext.ZetacoreContext().GetEnabledChains()) == 0 {
+	if len(appContext.GetEnabledChains()) == 0 {
 		startLogger.Error().Msgf("No chains enabled in updated config %s ", cfg.String())
 	}