refactor: using integrated name for variables and etc (#30)

config/config.go

@@ -99,7 +99,7 @@ func LoadConfig() (*Config, error) {
 }
 
 func (c *Config) basicCheck() error {
-	if c.Environment != "dev" && c.Environment != "prod" { //nolint
+	if c.Environment != "dev" && c.Environment != "prod" {
 		return InvalidEnvironmentError{
 			Environment: c.Environment,
 		}

database/database_test.go

@@ -25,19 +25,19 @@ func setup(t *testing.T) *database.DB {
 func TestAddOrder(t *testing.T) {
 	db := setup(t)
 
-	ordID, err := order.NewOrder("aaa", "sendet", "rec", 20e9)
+	ord, err := order.NewOrder("aaa", "sendet", "rec", 20e9)
 	assert.NoError(t, err)
 
-	o, err := db.AddOrder(ordID)
+	ordID, err := db.AddOrder(ord)
 	assert.NoError(t, err)
 
-	assert.Equal(t, ordID.ID, o)
+	assert.Equal(t, ord.ID, ordID)
 }
 
 func TestAddLog(t *testing.T) {
 	db := setup(t)
 
-	err := db.AddLog("dnslkn", "POLYGON", "this is abcd", "")
+	err := db.AddLog("1", "POLYGON", "this is test desc", "trace")
 	assert.NoError(t, err)
 }
 
@@ -47,20 +47,20 @@ func TestAddLogForOrder(t *testing.T) {
 	ord, err := order.NewOrder("aaa", "sendet", "rec", 20e9)
 	assert.NoError(t, err)
 
-	o, err := db.AddOrder(ord)
+	ordID, err := db.AddOrder(ord)
 	assert.NoError(t, err)
 
-	err = db.AddLog(o, "POLYGON", "descriptivjerijw", "trace")
+	err = db.AddLog(ordID, "POLYGON", "desc", "trace")
 	assert.NoError(t, err)
 }
 
 func TestUpdateOrderStatus(t *testing.T) {
 	db := setup(t)
 
-	newOrd, err := order.NewOrder("aaa", "sendet", "rec", 20e9)
+	ord, err := order.NewOrder("0xFFFF", "sender", "receiver", 2e9)
 	require.NoError(t, err)
 
-	ordID, err := db.AddOrder(newOrd)
+	ordID, err := db.AddOrder(ord)
 	require.NoError(t, err)
 
 	err = db.UpdateOrderStatus(ordID, order.COMPLETE)
@@ -75,20 +75,20 @@ func TestUpdateOrderStatus(t *testing.T) {
 func TestGetOrder(t *testing.T) {
 	db := setup(t)
 
-	newOrd, err := order.NewOrder("aaa", "sendet", "rec", 20e9)
+	ord, err := order.NewOrder("aaa", "sendet", "rec", 20e9)
 	require.NoError(t, err)
 
-	o, err := db.AddOrder(newOrd)
+	ordID, err := db.AddOrder(ord)
 	require.NoError(t, err)
 
-	retOrd, err := db.GetOrder(o)
+	retrievedOrd, err := db.GetOrder(ordID)
 	require.NoError(t, err)
-	assert.Equal(t, retOrd.ID, newOrd.ID)
-	assert.Equal(t, retOrd.TxHash, newOrd.TxHash)
-	assert.Equal(t, retOrd.Amount, newOrd.OriginalAmount())
-	assert.Equal(t, retOrd.Fee, newOrd.Fee())
-	assert.Equal(t, retOrd.Sender, newOrd.Sender)
-	assert.Equal(t, retOrd.Receiver, newOrd.Receiver)
+	assert.Equal(t, retrievedOrd.ID, ord.ID)
+	assert.Equal(t, retrievedOrd.TxHash, ord.TxHash)
+	assert.Equal(t, retrievedOrd.Amount, ord.OriginalAmount())
+	assert.Equal(t, retrievedOrd.Fee, ord.Fee())
+	assert.Equal(t, retrievedOrd.Sender, ord.Sender)
+	assert.Equal(t, retrievedOrd.Receiver, ord.Receiver)
 }
 
 func TestGetOrderWithLogs(t *testing.T) {

log/logger.go

@@ -21,15 +21,9 @@ var (
 )
 
 type logger struct {
-	subs   map[string]*SubLogger
 	writer io.Writer
 }
 
-type SubLogger struct {
-	logger zerolog.Logger
-	name   string
-}
-
 func InitGlobalLogger(cfg *config.LoggerConfig) {
 	if globalInst == nil {
 		writers := []io.Writer{}
@@ -45,48 +39,31 @@ func InitGlobalLogger(cfg *config.LoggerConfig) {
 		}
 
 		if slices.Contains(cfg.Targets, "console") {
-			// Console writer.
 			writers = append(writers, zerolog.ConsoleWriter{Out: os.Stderr, TimeFormat: "15:04:05"})
 		}
 
 		globalInst = &logger{
-			subs:   make(map[string]*SubLogger),
 			writer: io.MultiWriter(writers...),
 		}
 
-		// Set the global log level from the configuration.
 		level, err := zerolog.ParseLevel(strings.ToLower(cfg.LogLevel))
 		if err != nil {
-			level = zerolog.InfoLevel // Default to info level if parsing fails.
+			level = zerolog.InfoLevel
 		}
 		zerolog.SetGlobalLevel(level)
 
 		log.Logger = zerolog.New(globalInst.writer).With().Timestamp().Logger()
 	}
 }
 
-// NewLoggerLevel initializes the logger level.
 func NewLoggerLevel(level zerolog.Level) {
 	logLevel = level
 }
 
-func getLoggersInst() *logger {
-	if globalInst == nil {
-		globalInst = &logger{
-			subs:   make(map[string]*SubLogger),
-			writer: zerolog.ConsoleWriter{Out: os.Stderr, TimeFormat: "15:04:05"},
-		}
-		log.Logger = zerolog.New(globalInst.writer).With().Timestamp().Logger()
-	}
-
-	return globalInst
-}
-
-// function to set logger level based on env.
 func SetLoggerLevel(level string) {
 	parsedLevel, err := zerolog.ParseLevel(strings.ToLower(level))
 	if err != nil {
-		parsedLevel = zerolog.InfoLevel // Default to info level if parsing fails
+		parsedLevel = zerolog.InfoLevel
 	}
 	logLevel = parsedLevel
 }
@@ -126,50 +103,6 @@ func addFields(event *zerolog.Event, keyvals ...interface{}) *zerolog.Event {
 	return event
 }
 
-func NewSubLogger(name string) *SubLogger {
-	inst := getLoggersInst()
-	sl := &SubLogger{
-		logger: zerolog.New(inst.writer).With().Timestamp().Logger(),
-		name:   name,
-	}
-
-	inst.subs[name] = sl
-
-	return sl
-}
-
-func (sl *SubLogger) logObj(event *zerolog.Event, msg string, keyvals ...interface{}) {
-	addFields(event, keyvals...).Msg(msg)
-}
-
-func (sl *SubLogger) Trace(msg string, keyvals ...interface{}) {
-	sl.logObj(sl.logger.Trace(), msg, keyvals...)
-}
-
-func (sl *SubLogger) Debug(msg string, keyvals ...interface{}) {
-	sl.logObj(sl.logger.Debug(), msg, keyvals...)
-}
-
-func (sl *SubLogger) Info(msg string, keyvals ...interface{}) {
-	sl.logObj(sl.logger.Info(), msg, keyvals...)
-}
-
-func (sl *SubLogger) Warn(msg string, keyvals ...interface{}) {
-	sl.logObj(sl.logger.Warn(), msg, keyvals...)
-}
-
-func (sl *SubLogger) Error(msg string, keyvals ...interface{}) {
-	sl.logObj(sl.logger.Error(), msg, keyvals...)
-}
-
-func (sl *SubLogger) Fatal(msg string, keyvals ...interface{}) {
-	sl.logObj(sl.logger.Fatal(), msg, keyvals...)
-}
-
-func (sl *SubLogger) Panic(msg string, keyvals ...interface{}) {
-	sl.logObj(sl.logger.Panic(), msg, keyvals...)
-}
-
 func Trace(msg string, keyvals ...interface{}) {
 	addFields(log.Trace(), keyvals...).Msg(msg)
 }

sides/manager/errors.go

@@ -11,5 +11,5 @@ type BypassNotFoundError struct {
 }
 
 func (e BypassNotFoundError) Error() string {
-	return fmt.Sprintf("%s not found", e.BypassName)
+	return fmt.Sprintf("bypass %s not found", e.BypassName)
 }

sides/pactus/bridge.go

@@ -41,7 +41,7 @@ func (b Bridge) Start() error {
 
 			return nil
 		case msg := <-b.bypass:
-			err := b.processMsg(msg)
+			err := b.processMessage(msg)
 			if err != nil {
 				logger.Error("error while processing message in bridge",
 					"actor", b.bypassName, "orderID", msg.Payload.ID)
@@ -52,7 +52,7 @@ func (b Bridge) Start() error {
 	}
 }
 
-func (b Bridge) processMsg(msg message.Message) error {
+func (b Bridge) processMessage(msg message.Message) error {
 	logger.Info("new message received for process", "actor", b.bypassName, "orderID", msg.Payload.ID)
 
 	err := b.db.AddLog(msg.Payload.ID, string(b.bypassName), "order received as message", "")

sides/pactus/client.go

@@ -16,7 +16,7 @@ type Client struct {
 	ctx context.Context
 }
 
-func newClient(c context.Context, endpoint string) (*Client, error) {
+func newClient(ctx context.Context, endpoint string) (*Client, error) {
 	conn, err := grpc.Dial(endpoint,
 		grpc.WithTransportCredentials(insecure.NewCredentials()))
 	if err != nil {
@@ -27,7 +27,7 @@ func newClient(c context.Context, endpoint string) (*Client, error) {
 		blockchainClient:  pactus.NewBlockchainClient(conn),
 		transactionClient: pactus.NewTransactionClient(conn),
 		conn:              conn,
-		ctx:               c,
+		ctx:               ctx,
 	}, nil
 }
 

sides/pactus/listener.go

@@ -15,12 +15,12 @@ import (
 )
 
 type Listener struct {
-	client     *Client
-	db         *database.DB
-	nextBlock  uint32
-	bypassName bypass.Name
-	highway    chan message.Message
-	lockAddr   string
+	client          *Client
+	db              *database.DB
+	nextBlockNumber uint32
+	bypassName      bypass.Name
+	highway         chan message.Message
+	lockAddr        string
 
 	ctx context.Context
 }
@@ -31,12 +31,12 @@ func newListener(ctx context.Context,
 	db *database.DB,
 ) *Listener {
 	return &Listener{
-		client:     client,
-		db:         db,
-		bypassName: bp,
-		highway:    highway,
-		nextBlock:  startBlock,
-		lockAddr:   lockAddr,
+		client:          client,
+		db:              db,
+		bypassName:      bp,
+		highway:         highway,
+		nextBlockNumber: startBlock,
+		lockAddr:        lockAddr,
 
 		ctx: ctx,
 	}
@@ -47,7 +47,7 @@ func (l *Listener) Start() error {
 	for {
 		select {
 		case <-l.ctx.Done():
-			logger.Info("stopping listener", "actor", l.bypassName, "nextBlock", l.nextBlock)
+			logger.Info("stopping listener", "actor", l.bypassName, "nextBlock", l.nextBlockNumber)
 			_ = l.client.Close()
 
 			return nil
@@ -62,7 +62,7 @@ func (l *Listener) Start() error {
 }
 
 func (l *Listener) processBlocks() error {
-	ok, err := l.isEligibleBlock(l.nextBlock)
+	ok, err := l.isEligibleBlock(l.nextBlockNumber)
 	if err != nil {
 		return err // TODO: handle errors from client
 	}
@@ -73,14 +73,14 @@ func (l *Listener) processBlocks() error {
 		return nil
 	}
 
-	blk, err := l.client.GetBlock(l.nextBlock)
+	blk, err := l.client.GetBlock(l.nextBlockNumber)
 	if err != nil {
 		return err // TODO: handle errors from client
 	}
 
-	l.nextBlock++
+	l.nextBlockNumber++
 
-	validTxs := l.filterValidTxs(blk.Txs)
+	validTxs := l.filterValidTransactions(blk.Txs)
 
 	logger.Info("start processing new block", "actor", l.bypassName, "height", blk.Height)
 	for _, tx := range validTxs {
@@ -91,14 +91,14 @@ func (l *Listener) processBlocks() error {
 		logger.Info("processing new tx", "actor", l.bypassName, "height", blk.Height, "txID", txHash,
 			"amount", amt, "sender", sender)
 
-		dest, err := ParseMemo(tx.Memo)
+		destInfo, err := ParseMemo(tx.Memo)
 		if err != nil {
 			logger.Info("invalid memo", "memo", tx.Memo)
 
 			continue
 		}
 
-		ord, err := order.NewOrder(txHash, sender, dest.Addr, amt)
+		ord, err := order.NewOrder(txHash, sender, destInfo.Addr, amt)
 		if err != nil {
 			logger.Error("error while making new order", "actor", l.bypassName, "err", err,
 				"height", blk.Height, "txID", txHash)
@@ -115,30 +115,30 @@ func (l *Listener) processBlocks() error {
 			continue
 		}
 
-		msg := message.NewMessage(dest.BypassName, l.bypassName, ord)
+		msg := message.NewMessage(destInfo.BypassName, l.bypassName, ord)
 		l.highway <- msg
 
 		logger.Info("sending order message to highway", "actor", l.bypassName, "height",
 			blk.Height, "txID", txHash, "orderID", ord.ID)
-		dbErr := l.db.AddLog(ord.ID, "PACTUS", "sent order to highway", "")
-		if dbErr != nil {
-			return dbErr
+		err = l.db.AddLog(ord.ID, "PACTUS", "sent order to highway", "")
+		if err != nil {
+			return err
 		}
 	}
 
 	return nil
 }
 
 func (l *Listener) isEligibleBlock(h uint32) (bool, error) {
-	lst, err := l.client.GetLastBlockHeight()
+	lbh, err := l.client.GetLastBlockHeight()
 	if err != nil {
 		return false, err
 	}
 
-	return h < lst, nil
+	return h < lbh, nil
 }
 
-func (l *Listener) filterValidTxs(txs []*pactus.TransactionInfo) []*pactus.TransactionInfo {
+func (l *Listener) filterValidTransactions(txs []*pactus.TransactionInfo) []*pactus.TransactionInfo {
 	validTxs := make([]*pactus.TransactionInfo, 0)
 
 	for _, tx := range txs {

sides/pactus/pactus.go

@@ -23,7 +23,7 @@ type Side struct {
 
 func NewSide(ctx context.Context,
 	highway chan message.Message, startBlock uint32,
-	b chan message.Message, env string, cfg config.PactusConfig,
+	bp chan message.Message, env string, cfg config.PactusConfig,
 	db *database.DB,
 ) (*Side, error) {
 	if env == "dev" {
@@ -41,7 +41,7 @@ func NewSide(ctx context.Context,
 	}
 
 	listener := newListener(ctx, client, bypass.PACTUS, highway, startBlock, cfg.LockAddr, db)
-	bridge := newBridge(ctx, wallet, b, bypass.PACTUS, db)
+	bridge := newBridge(ctx, wallet, bp, bypass.PACTUS, db)
 
 	return &Side{
 		client:   client,