feat(zetaclient): add support for EIP-1559 outbound transactions

changelog.md

@@ -30,6 +30,7 @@
 * [2339](https://github.com/zeta-chain/node/pull/2339) - add binaries related question to syncing issue form
 * [2366](https://github.com/zeta-chain/node/pull/2366) - add migration script for adding authorizations table
 * [2372](https://github.com/zeta-chain/node/pull/2372) - add queries for tss fund migration info
+* [2387](https://github.com/zeta-chain/node/pull/2387) - add support for EIP-1559 outbound transactions
 
 ### Refactor
 

cmd/zetaclientd/start.go

@@ -77,7 +77,7 @@ func start(_ *cobra.Command, _ []string) error {
 		}
 	}
 
-	masterLogger := logger.Std
+	masterLogger := logger.Logger
 	startLogger := masterLogger.With().Str("module", "startup").Logger()
 
 	// Wait until zetacore is up
@@ -299,7 +299,7 @@ func start(_ *cobra.Command, _ []string) error {
 	}
 
 	// Orchestrator wraps the zetacore client and adds the observers and signer maps to it . This is the high level object used for CCTX interactions
-	orchestrator := orchestrator.NewOrchestrator(zetacoreClient, signerMap, observerMap, masterLogger, telemetryServer)
+	orchestrator := orchestrator.New(zetacoreClient, signerMap, observerMap, masterLogger, telemetryServer)
 	err = orchestrator.MonitorCore(appContext)
 	if err != nil {
 		startLogger.Error().Err(err).Msg("Orchestrator failed to start")

cmd/zetaclientd/utils.go

@@ -75,7 +75,7 @@ func CreateSignerMap(
 		}
 		evmChainParams, found := zetacoreContext.GetEVMChainParams(evmConfig.Chain.ChainId)
 		if !found {
-			logger.Std.Error().Msgf("ChainParam not found for chain %s", evmConfig.Chain.String())
+			logger.Error().Msgf("ChainParam not found for chain %s", evmConfig.Chain.String())
 			continue
 		}
 		mpiAddress := ethcommon.HexToAddress(evmChainParams.ConnectorContractAddress)
@@ -92,7 +92,7 @@ func CreateSignerMap(
 			mpiAddress,
 			erc20CustodyAddress)
 		if err != nil {
-			logger.Std.Error().Err(err).Msgf("NewEVMSigner error for chain %s", evmConfig.Chain.String())
+			logger.Error().Err(err).Msgf("NewEVMSigner error for chain %s", evmConfig.Chain.String())
 			continue
 		}
 		signerMap[evmConfig.Chain.ChainId] = signer
@@ -102,7 +102,7 @@ func CreateSignerMap(
 	if enabled {
 		signer, err := btcsigner.NewSigner(btcChain, zetacoreContext, tss, ts, logger, btcConfig)
 		if err != nil {
-			logger.Std.Error().Err(err).Msgf("NewBTCSigner error for chain %s", btcChain.String())
+			logger.Error().Err(err).Msgf("NewBTCSigner error for chain %s", btcChain.String())
 		} else {
 			signerMap[btcChain.ChainId] = signer
 		}
@@ -129,14 +129,14 @@ func CreateChainObserverMap(
 		}
 		chainParams, found := zetacoreContext.GetEVMChainParams(evmConfig.Chain.ChainId)
 		if !found {
-			logger.Std.Error().Msgf("ChainParam not found for chain %s", evmConfig.Chain.String())
+			logger.Error().Msgf("ChainParam not found for chain %s", evmConfig.Chain.String())
 			continue
 		}
 
 		// create EVM client
 		evmClient, err := ethclient.Dial(evmConfig.Endpoint)
 		if err != nil {
-			logger.Std.Error().Err(err).Msgf("error dailing endpoint %s", evmConfig.Endpoint)
+			logger.Error().Err(err).Msgf("error dailing endpoint %s", evmConfig.Endpoint)
 			continue
 		}
 
@@ -153,7 +153,7 @@ func CreateChainObserverMap(
 			ts,
 		)
 		if err != nil {
-			logger.Std.Error().Err(err).Msgf("NewObserver error for evm chain %s", evmConfig.Chain.String())
+			logger.Error().Err(err).Msgf("NewObserver error for evm chain %s", evmConfig.Chain.String())
 			continue
 		}
 		observerMap[evmConfig.Chain.ChainId] = observer
@@ -170,7 +170,7 @@ func CreateChainObserverMap(
 	if enabled {
 		btcClient, err := btcrpc.NewRPCClient(btcConfig)
 		if err != nil {
-			logger.Std.Error().Err(err).Msgf("error creating rpc client for bitcoin chain %s", btcChain.String())
+			logger.Error().Err(err).Msgf("error creating rpc client for bitcoin chain %s", btcChain.String())
 		} else {
 			// create BTC chain observer
 			observer, err := btcobserver.NewObserver(
@@ -185,7 +185,7 @@ func CreateChainObserverMap(
 				ts,
 			)
 			if err != nil {
-				logger.Std.Error().Err(err).Msgf("NewObserver error for bitcoin chain %s", btcChain.String())
+				logger.Error().Err(err).Msgf("NewObserver error for bitcoin chain %s", btcChain.String())
 			} else {
 				observerMap[btcChain.ChainId] = observer
 			}

docs/development/LOCAL_TESTING.md

@@ -144,7 +144,7 @@ docker exec -it zetacore0 sh
 Performing a query:
 
 ```bash
-zetacored q bank balances zeta1amcsn7ja3608dj74xt93pcu5guffsyu2xfdcyp
+zetacored q bank balances zeta1338n99nkny4yyyklj0l4adwn8hqhdevknnvdle
 ```
 
 Sending a transaction:

zetaclient/chains/base/logger.go

@@ -17,14 +17,14 @@ const (
 
 // Logger contains the base loggers
 type Logger struct {
-	Std        zerolog.Logger
+	zerolog.Logger
 	Compliance zerolog.Logger
 }
 
 // DefaultLoggers creates default base loggers for tests
 func DefaultLogger() Logger {
 	return Logger{
-		Std:        log.Logger,
+		Logger:     log.Logger,
 		Compliance: log.Logger,
 	}
 }
@@ -58,9 +58,12 @@ func InitLogger(cfg config.Config) (Logger, error) {
 		return DefaultLogger(), err
 	}
 
+	var (
+		std        zerolog.Logger
+		compliance zerolog.Logger
+	)
+
 	// create loggers based on configured level and format
-	var std zerolog.Logger
-	var compliance zerolog.Logger
 	switch cfg.LogFormat {
 	case "json":
 		std = zerolog.New(os.Stdout).Level(zerolog.Level(cfg.LogLevel)).With().Timestamp().Logger()
@@ -80,12 +83,8 @@ func InitLogger(cfg config.Config) (Logger, error) {
 	if cfg.LogSampler {
 		std = std.Sample(&zerolog.BasicSampler{N: 5})
 	}
-	log.Logger = std // set global logger
 
-	return Logger{
-		Std:        std,
-		Compliance: compliance,
-	}, nil
+	return Logger{Logger: std, Compliance: compliance}, nil
 }
 
 // openComplianceLogFile opens the compliance log file

zetaclient/chains/base/logger_test.go

@@ -91,7 +91,7 @@ func TestInitLogger(t *testing.T) {
 			require.NoError(t, err)
 
 			// should be able to print log
-			logger.Std.Info().Msg("print standard log")
+			logger.Info().Msg("print standard log")
 			logger.Compliance.Info().Msg("print compliance log")
 		})
 	}

zetaclient/chains/base/observer.go

@@ -266,7 +266,7 @@
 
 // WithLogger attaches a new logger to the observer.
 func (ob *Observer) WithLogger(logger Logger) *Observer {
-	chainLogger := logger.Std.With().Int64("chain", ob.chain.ChainId).Logger()
+	chainLogger := logger.With().Int64("chain", ob.chain.ChainId).Logger()
 	ob.logger = ObserverLogger{
 		Chain:      chainLogger,
 		Inbound:    chainLogger.With().Str("module", "inbound").Logger(),
@@ -290,27 +290,26 @@
 
 // OpenDB open sql database in the given path.
 func (ob *Observer) OpenDB(dbPath string, dbName string) error {
-	// create db path if not exist
-	if _, err := os.Stat(dbPath); os.IsNotExist(err) {
-		err := os.MkdirAll(dbPath, os.ModePerm)
-		if err != nil {
-			return errors.Wrapf(err, "error creating db path: %s", dbPath)
+	var dial gorm.Dialector
+
+	// SQLite in-mem db
+	if strings.Contains(dbPath, ":memory:") {
+		dial = sqlite.Open(dbPath)
+	} else {
+		if err := ensureDirectory(dbPath); err != nil {
+			return errors.Wrapf(err, "unable to ensure dbPath %q", dbPath)
 		}
-	}
 
-	// use custom dbName or chain name if not provided
-	if dbName == "" {
-		dbName = ob.chain.ChainName.String()
-	}
-	path := fmt.Sprintf("%s/%s", dbPath, dbName)
+		// use custom dbName or chain name if not provided
+		if dbName == "" {
+			dbName = ob.chain.ChainName.String()
+		}
 
-	// use memory db if specified
-	if strings.Contains(dbPath, ":memory:") {
-		path = dbPath
+		dial = sqlite.Open(fmt.Sprintf("%s/%s", dbPath, dbName))
 	}
 
 	// open db
-	db, err := gorm.Open(sqlite.Open(path), &gorm.Config{Logger: logger.Default.LogMode(logger.Silent)})
+	db, err := gorm.Open(dial, &gorm.Config{Logger: logger.Default.LogMode(logger.Silent)})
 	if err != nil {
 		return errors.Wrap(err, "error opening db")
 	}
@@ -320,11 +319,24 @@
 	if err != nil {
 		return errors.Wrap(err, "error migrating db")
 	}
+
 	ob.db = db
 
 	return nil
 }
 
+func ensureDirectory(path string) error {
+	_, err := os.Stat(path)
+	switch {
+	case os.IsNotExist(err):
+		return os.MkdirAll(path, os.ModePerm)
+	case err != nil:
+		return err
+	default:
+		return nil
+	}
+}
+
 // CloseDB close the database.
 func (ob *Observer) CloseDB() error {
 	dbInst, err := ob.db.DB()

zetaclient/chains/base/observer_test.go

@@ -276,7 +276,7 @@ func TestOpenCloseDB(t *testing.T) {
 	})
 	t.Run("should return error on invalid db path", func(t *testing.T) {
 		err := ob.OpenDB("/invalid/123db", "")
-		require.ErrorContains(t, err, "error creating db path")
+		require.ErrorContains(t, err, "unable to ensure dbPath")
 	})
 }
 

zetaclient/chains/base/signer.go

@@ -46,7 +46,7 @@ func NewSigner(
 		tss:             tss,
 		ts:              ts,
 		logger: Logger{
-			Std:        logger.Std.With().Int64("chain", chain.ChainId).Str("module", "signer").Logger(),
+			Logger:     logger.With().Int64("chain", chain.ChainId).Str("module", "signer").Logger(),
 			Compliance: logger.Compliance,
 		},
 	}

zetaclient/chains/base/signer_test.go

@@ -68,7 +68,7 @@ func TestSignerGetterAndSetter(t *testing.T) {
 		logger := ob.Logger()
 
 		// should be able to print log
-		logger.Std.Info().Msg("print standard log")
+		logger.Info().Msg("print standard log")
 		logger.Compliance.Info().Msg("print compliance log")
 	})
 }

zetaclient/chains/bitcoin/observer/observer_test.go

@@ -161,7 +161,7 @@ func Test_NewObserver(t *testing.T) {
 			logger:      base.Logger{},
 			ts:          nil,
 			fail:        true,
-			message:     "error creating db path",
+			message:     "unable to ensure dbPath",
 		},
 	}
 

zetaclient/chains/bitcoin/signer/signer.go

@@ -134,7 +134,7 @@
 	if remainingSats < 0 {
 		return fmt.Errorf("remainder value is negative: %d", remainingSats)
 	} else if remainingSats == nonceMark {
-		signer.Logger().Std.Info().Msgf("adjust remainder value to avoid duplicate nonce-mark: %d", remainingSats)
+		signer.Logger().Info().Msgf("adjust remainder value to avoid duplicate nonce-mark: %d", remainingSats)
 		remainingSats--
 	}
 
@@ -188,7 +188,7 @@
 	err := observer.FetchUTXOs()
 	if err != nil {
 		signer.Logger().
-			Std.Error().
+			Error().
 			Err(err).
 			Msgf("SignWithdrawTx: FetchUTXOs error: nonce %d chain %d", nonce, chain.ChainId)
 	}
@@ -224,25 +224,24 @@
 		return nil, err
 	}
 	if sizeLimit < bitcoin.BtcOutboundBytesWithdrawer { // ZRC20 'withdraw' charged less fee from end user
-		signer.Logger().Std.Info().
+		signer.Logger().Info().
 			Msgf("sizeLimit %d is less than BtcOutboundBytesWithdrawer %d for nonce %d", sizeLimit, txSize, nonce)
 	}
 	if txSize < bitcoin.OutboundBytesMin { // outbound shouldn't be blocked a low sizeLimit
-		signer.Logger().Std.Warn().
+		signer.Logger().Warn().
 			Msgf("txSize %d is less than outboundBytesMin %d; use outboundBytesMin", txSize, bitcoin.OutboundBytesMin)
 		txSize = bitcoin.OutboundBytesMin
 	}
 	if txSize > bitcoin.OutboundBytesMax { // in case of accident
-		signer.Logger().Std.Warn().
+		signer.Logger().Warn().
 			Msgf("txSize %d is greater than outboundBytesMax %d; use outboundBytesMax", txSize, bitcoin.OutboundBytesMax)
 		txSize = bitcoin.OutboundBytesMax
 	}
 
 	// fee calculation
 	// #nosec G701 always in range (checked above)
 	fees := new(big.Int).Mul(big.NewInt(int64(txSize)), gasPrice)
-	signer.Logger().
-		Std.Info().
+	signer.Logger().Info().
 		Msgf("bitcoin outbound nonce %d gasPrice %s size %d fees %s consolidated %d utxos of value %v",
 			nonce, gasPrice.String(), txSize, fees.String(), consolidatedUtxo, consolidatedValue)
 
@@ -310,7 +309,7 @@
 		return err
 	}
 
-	signer.Logger().Std.Info().Msgf("Broadcasting BTC tx , hash %s ", hash)
+	signer.Logger().Info().Msgf("Broadcasting BTC tx , hash %s ", hash)
 	return nil
 }
 
@@ -327,11 +326,11 @@
 	defer func() {
 		outboundProcessor.EndTryProcess(outboundID)
 		if err := recover(); err != nil {
-			signer.Logger().Std.Error().Msgf("BTC TryProcessOutbound: %s, caught panic error: %v", cctx.Index, err)
+			signer.Logger().Error().Msgf("BTC TryProcessOutbound: %s, caught panic error: %v", cctx.Index, err)
 		}
 	}()
 
-	logger := signer.Logger().Std.With().
+	logger := signer.Logger().With().
 		Str("OutboundID", outboundID).
 		Str("SendHash", cctx.Index).
 		Logger()