Stat layer1 tx. (#12)

Author: Argeric

api/api.go

@@ -6,8 +6,8 @@ import (
 	"github.com/gin-gonic/gin"
 	"github.com/openweb3/web3go"
 	"github.com/sirupsen/logrus"
-	"github.com/swaggo/files"
-	"github.com/swaggo/gin-swagger"
+	swaggerFiles "github.com/swaggo/files"
+	ginSwagger "github.com/swaggo/gin-swagger"
 	nhContract "github.com/zero-gravity-labs/zerog-storage-scan/contract"
 	"github.com/zero-gravity-labs/zerog-storage-scan/docs"
 	"github.com/zero-gravity-labs/zerog-storage-scan/store"
@@ -16,11 +16,9 @@ import (
 const BasePath = "/api"
 
 var (
-	sdk           *web3go.Client
-	db            *store.MysqlStore
-	chargeToken   *TokenInfo
-	flowAddr      string
-	flowSubmitSig string
+	sdk         *web3go.Client
+	db          *store.MysqlStore
+	chargeToken *TokenInfo
 )
 
 func MustInit(client *web3go.Client, store *store.MysqlStore) {
@@ -49,8 +47,6 @@ func MustInit(client *web3go.Client, store *store.MysqlStore) {
 		SubmitEventSignature string
 	}
 	viperutil.MustUnmarshalKey("flow", &flow)
-	flowAddr = flow.Address
-	flowSubmitSig = flow.SubmitEventSignature
 }
 
 // @title		ZeroGStorage Scan API

api/errors.go

@@ -5,8 +5,6 @@ import (
 )
 
 var (
-	ErrConfigNotFound        = commonApi.NewBusinessError(1001, "Config not found", nil)
-	ErrAddressNotFound       = commonApi.NewBusinessError(1002, "Account not found", nil)
 	ErrStatTypeNotSupported  = commonApi.NewBusinessError(1003, "Stat type not supported", nil)
 	ErrStorageBaseFeeNotStat = commonApi.NewBusinessError(1004, "Storage base fee not stat", nil)
 )

api/stat_api.go

@@ -79,8 +79,8 @@ func getSubmitStatByType(c *gin.Context, t Type) (interface{}, error) {
 		for _, r := range records {
 			list = append(list, TxStat{
 				StatTime: r.StatTime,
-				TxCount:  r.FileCount,
-				TxTotal:  r.FileTotal,
+				TxCount:  r.TxCount,
+				TxTotal:  r.TxTotal,
 			})
 		}
 		result["list"] = list

cmd/stat.go

@@ -2,11 +2,12 @@ package cmd
 
 import (
 	"context"
+	"sync"
+
 	"github.com/Conflux-Chain/go-conflux-util/viper"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 	"github.com/zero-gravity-labs/zerog-storage-scan/stat"
-	"sync"
 )
 
 var (

stat/stat.go

@@ -26,38 +26,22 @@ type StatConfig struct {
 }
 
 type TimeRange struct {
-	start *time.Time
-	end   *time.Time
+	start time.Time
+	end   time.Time
 }
 
 type BaseStat struct {
 	Config    *StatConfig
 	DB        *store.MysqlStore
 	Sdk       *web3go.Client
-	StartTime *time.Time
+	StartTime time.Time
 }
 
-func (bs *BaseStat) defaultRangeStart() (*time.Time, error) {
-	if bs.Config.BlockOnStatBegin == uint64(0) {
-		return nil, errors.New("missing block from which the stat begin")
-	}
-
-	block, err := bs.Sdk.Eth.BlockByNumber(types.BlockNumber(bs.Config.BlockOnStatBegin), false)
-	if err != nil {
-		return nil, err
-	}
-
-	t := time.Unix(int64(block.Timestamp), 0).UTC()
-	rangeStart := time.Date(t.Year(), t.Month(), t.Day(), t.Hour(), 0, 0, 0, t.Location())
-
-	return &rangeStart, nil
-}
-
-func (bs *BaseStat) calStatRange(rangeStart *time.Time, interval time.Duration) (*TimeRange, error) {
+func (bs *BaseStat) calStatRange(rangeStart time.Time, interval time.Duration) (*TimeRange, error) {
 	rangeEnd := rangeStart.Add(interval)
 	timeRange := TimeRange{
 		start: rangeStart,
-		end:   &rangeEnd,
+		end:   rangeEnd,
 	}
 	return &timeRange, nil
 }
@@ -75,7 +59,7 @@ Range in Hour
 current time "2023-01-01 01:00:00", expect range start time "2023-01-01 00:00:00"
 current time "2023-01-01 00:00:00", expect range start time "2022-12-31 23:00:00"
 */
-func (bs *BaseStat) calStatRangeStart(t *time.Time, statType string) (*time.Time, error) {
+func (bs *BaseStat) calStatRangeStart(t time.Time, statType string) (time.Time, error) {
 	var rangeStart time.Time
 	timeFormat := t.Format("2006-01-02 15:04:05")
 
@@ -96,20 +80,20 @@ func (bs *BaseStat) calStatRangeStart(t *time.Time, statType string) (*time.Time
 			rangeStart = rangeStart.Add(-time.Hour)
 		}
 	default:
-		return nil, errors.Errorf("stat type %v not supported", statType)
+		return time.Time{}, errors.Errorf("stat type %v not supported", statType)
 	}
 
-	return &rangeStart, nil
+	return rangeStart, nil
 }
 
-func (bs *BaseStat) firstBlockAfterRangeEnd(rangeEnd *time.Time) (uint64, bool, error) {
+func (bs *BaseStat) firstBlockAfterRangeEnd(rangeEnd time.Time) (uint64, bool, error) {
 	return bs.DB.FirstBlockAfterTime(rangeEnd)
 }
 
 type Stat interface {
 	nextTimeRange() (*TimeRange, error)
-	firstBlockAfterRangeEnd(rangeEnd *time.Time) (uint64, bool, error)
-	calculateStat(*TimeRange) error
+	firstBlockAfterRangeEnd(rangeEnd time.Time) (uint64, bool, error)
+	calculateStat(TimeRange) error
 }
 
 type AbsStat struct {
@@ -140,7 +124,7 @@ func (as *AbsStat) DoStat(ctx context.Context, wg *sync.WaitGroup) {
 			continue
 		}
 
-		err = as.calculateStat(timeRange)
+		err = as.calculateStat(*timeRange)
 		if err != nil {
 			logrus.WithError(err).Error("do stat")
 			time.Sleep(time.Second * 10)
@@ -154,7 +138,7 @@ func (as *AbsStat) tryAcquireTimeRange() (*TimeRange, error) {
 	if err != nil {
 		return nil, err
 	}
-	if time.Now().UTC().Before(*timeRange.end) {
+	if time.Now().UTC().Before(timeRange.end) {
 		return nil, ErrTimeNotReach
 	}
 
@@ -186,7 +170,7 @@ func (as *AbsStat) interrupted(ctx context.Context) bool {
 	return false
 }
 
-func MustDefaultRangeStart(sdk *web3go.Client) *time.Time {
+func MustDefaultRangeStart(sdk *web3go.Client) time.Time {
 	start, err := defaultRangeStart(sdk)
 	if err != nil {
 		logrus.WithError(err).Fatal("Failed to get default start time for stat task")
@@ -195,21 +179,21 @@ func MustDefaultRangeStart(sdk *web3go.Client) *time.Time {
 	return start
 }
 
-func defaultRangeStart(sdk *web3go.Client) (*time.Time, error) {
+func defaultRangeStart(sdk *web3go.Client) (time.Time, error) {
 	config := StatConfig{}
 	viper.MustUnmarshalKey("stat", &config)
 
 	if config.BlockOnStatBegin == uint64(0) {
-		return nil, errors.New("missing block from which the stat begin")
+		return time.Time{}, errors.New("missing block from which the stat begin")
 	}
 
 	block, err := sdk.Eth.BlockByNumber(types.BlockNumber(config.BlockOnStatBegin), false)
 	if err != nil {
-		return nil, err
+		return time.Time{}, err
 	}
 
 	t := time.Unix(int64(block.Timestamp), 0).UTC()
 	rangeStart := time.Date(t.Year(), t.Month(), t.Day(), t.Hour(), 0, 0, 0, t.Location())
 
-	return &rangeStart, nil
+	return rangeStart, nil
 }

stat/stat_submit.go

@@ -14,7 +14,7 @@ type StatSubmit struct {
 	statType string
 }
 
-func MustNewStatSubmit(cfg *StatConfig, db *store.MysqlStore, sdk *web3go.Client, startTime *time.Time) *AbsStat {
+func MustNewStatSubmit(cfg *StatConfig, db *store.MysqlStore, sdk *web3go.Client, startTime time.Time) *AbsStat {
 	baseStat := &BaseStat{
 		Config:    cfg,
 		DB:        db,
@@ -39,12 +39,12 @@ func (ts *StatSubmit) nextTimeRange() (*TimeRange, error) {
 		return nil, err
 	}
 
-	var nextRangeStart *time.Time
+	var nextRangeStart time.Time
 	if lastStat == nil {
 		nextRangeStart = ts.StartTime
 	} else {
 		t := lastStat.StatTime.Add(store.Intervals[ts.statType])
-		nextRangeStart = &t
+		nextRangeStart = t
 	}
 
 	timeRange, err := ts.calStatRange(nextRangeStart, store.Intervals[ts.statType])
@@ -55,7 +55,7 @@ func (ts *StatSubmit) nextTimeRange() (*TimeRange, error) {
 	return timeRange, nil
 }
 
-func (ts *StatSubmit) calculateStat(tr *TimeRange) error {
+func (ts *StatSubmit) calculateStat(tr TimeRange) error {
 	stat, err := ts.statBasicRange(tr)
 	if err != nil {
 		return err
@@ -84,29 +84,31 @@ func (ts *StatSubmit) calculateStat(tr *TimeRange) error {
 	})
 }
 
-func (ts *StatSubmit) statBasicRange(tr *TimeRange) (*store.SubmitStat, error) {
-	delta, err := ts.DB.SubmitStore.Count(*tr.start, *tr.end)
+func (ts *StatSubmit) statBasicRange(tr TimeRange) (*store.SubmitStat, error) {
+	delta, err := ts.DB.SubmitStore.Count(tr.start, tr.end)
 	if err != nil {
 		return nil, err
 	}
-	total, err := ts.DB.SubmitStatStore.Sum(nil, tr.start, ts.statType)
+	total, err := ts.DB.SubmitStatStore.Sum(time.Time{}, tr.start, ts.statType)
 	if err != nil {
 		return nil, err
 	}
 
 	return &store.SubmitStat{
-		StatTime:     *tr.start,
+		StatTime:     tr.start,
 		StatType:     ts.statType,
 		FileCount:    delta.FileCount,
 		FileTotal:    total.FileCount + delta.FileCount,
 		DataSize:     delta.DataSize,
 		DataTotal:    total.DataSize + delta.DataSize,
 		BaseFee:      delta.BaseFee,
 		BaseFeeTotal: total.BaseFee.Add(delta.BaseFee),
+		TxCount:      delta.TxCount,
+		TxTotal:      total.TxCount + delta.TxCount,
 	}, nil
 }
 
-func (ts *StatSubmit) statRange(rangEnd *time.Time, srcStatType, descStatType string, latestStat *store.SubmitStat) (*store.SubmitStat, error) {
+func (ts *StatSubmit) statRange(rangEnd time.Time, srcStatType, descStatType string, latestStat *store.SubmitStat) (*store.SubmitStat, error) {
 	rangeStart, err := ts.calStatRangeStart(rangEnd, descStatType)
 	if err != nil {
 		return nil, err
@@ -116,7 +118,7 @@ func (ts *StatSubmit) statRange(rangEnd *time.Time, srcStatType, descStatType st
 	if err != nil {
 		return nil, err
 	}
-	destStat, err := ts.DB.SubmitStatStore.Sum(nil, rangeStart, descStatType)
+	destStat, err := ts.DB.SubmitStatStore.Sum(time.Time{}, rangeStart, descStatType)
 	if err != nil {
 		return nil, err
 	}
@@ -125,16 +127,19 @@ func (ts *StatSubmit) statRange(rangEnd *time.Time, srcStatType, descStatType st
 		srcStat.FileCount += latestStat.FileCount
 		srcStat.DataSize += latestStat.DataSize
 		srcStat.BaseFee = srcStat.BaseFee.Add(latestStat.BaseFee)
+		srcStat.TxCount += latestStat.TxCount
 	}
 
 	return &store.SubmitStat{
-		StatTime:     *rangeStart,
+		StatTime:     rangeStart,
 		StatType:     descStatType,
 		FileCount:    srcStat.FileCount,
 		FileTotal:    destStat.FileCount + srcStat.FileCount,
 		DataSize:     srcStat.DataSize,
 		DataTotal:    destStat.DataSize + srcStat.DataSize,
 		BaseFee:      srcStat.BaseFee,
 		BaseFeeTotal: destStat.BaseFee.Add(srcStat.BaseFee),
+		TxCount:      srcStat.TxCount,
+		TxTotal:      destStat.TxCount + srcStat.TxCount,
 	}, nil
 }

store/store_block.go

@@ -68,7 +68,7 @@ func (bs *BlockStore) BlockHash(blockNumber uint64) (string, bool, error) {
 	return blk.Hash, existed, nil
 }
 
-func (bs *BlockStore) FirstBlockAfterTime(t *time.Time) (uint64, bool, error) {
+func (bs *BlockStore) FirstBlockAfterTime(t time.Time) (uint64, bool, error) {
 	var blk Block
 
 	result := bs.DB.Where("block_time >= ?", t).Order("block_time asc").Limit(1).Find(&blk)

store/store_submit.go

@@ -117,9 +117,9 @@ func (ss *SubmitStore) Pop(dbTx *gorm.DB, block uint64) error {
 
 func (ss *SubmitStore) Count(startTime, endTime time.Time) (*SubmitStatResult, error) {
 	var result SubmitStatResult
-	err := ss.DB.Model(&Submit{}).Select(`count(submission_index) as file_count, IFNULL(sum(length), 0) as data_size, 
-		IFNULL(sum(fee), 0) as base_fee`).Where("block_time >= ? and block_time < ?", startTime, endTime).
-		Find(&result).Error
+	err := ss.DB.Model(&Submit{}).Select(`count(submission_index) as file_count, 
+		IFNULL(sum(length), 0) as data_size, IFNULL(sum(fee), 0) as base_fee, count(distinct tx_hash) as tx_count`).
+		Where("block_time >= ? and block_time < ?", startTime, endTime).Find(&result).Error
 	if err != nil {
 		return nil, err
 	}

store/store_submit_stat.go

@@ -42,6 +42,8 @@ type SubmitStat struct {
 	DataTotal    uint64          `gorm:"not null;default:0" json:"dataTotal"`                     // Total Size of storage data by a certain time
 	BaseFee      decimal.Decimal `gorm:"type:decimal(65);not null;default:0" json:"baseFee"`      // The base fee for storage
 	BaseFeeTotal decimal.Decimal `gorm:"type:decimal(65);not null;default:0" json:"baseFeeTotal"` // The total base fee for storage
+	TxCount      uint64          `gorm:"not null;default:0" json:"txCount"`                       // Number of layer1 transaction in a specific time interval
+	TxTotal      uint64          `gorm:"not null;default:0" json:"txTotal"`                       // Total number of layer1 transaction by a certain time
 }
 
 func (SubmitStat) TableName() string {
@@ -60,7 +62,7 @@ func newSubmitStatStore(db *gorm.DB) *SubmitStatStore {
 
 func (t *SubmitStatStore) LastByType(statType string) (*SubmitStat, error) {
 	var submitStat SubmitStat
-	err := t.Store.DB.Where("stat_type = ?", statType).Order("stat_time asc").Last(&submitStat).Error
+	err := t.Store.DB.Where("stat_type = ?", statType).Order("stat_time desc").Last(&submitStat).Error
 	if errors.Is(err, gorm.ErrRecordNotFound) {
 		return nil, nil
 	}
@@ -74,22 +76,25 @@ type SubmitStatResult struct {
 	FileCount uint64
 	DataSize  uint64
 	BaseFee   decimal.Decimal
+	TxCount   uint64
 }
 
-func (t *SubmitStatStore) Sum(startTime, endTime *time.Time, statType string) (*SubmitStatResult, error) {
-	if startTime == nil && endTime == nil {
+func (t *SubmitStatStore) Sum(startTime, endTime time.Time, statType string) (*SubmitStatResult, error) {
+	nilTime := time.Time{}
+	if startTime == nilTime && endTime == nilTime {
 		return nil, errors.New("At least provide one parameter for startTime and endTime")
 	}
 
 	db := t.DB.Model(&SubmitStat{}).Select(`IFNULL(sum(file_count), 0) as file_count, 
-		IFNULL(sum(data_size), 0) as data_size, IFNULL(sum(base_fee), 0) as base_fee`)
-	if startTime != nil && endTime != nil {
+		IFNULL(sum(data_size), 0) as data_size, IFNULL(sum(base_fee), 0) as base_fee, 
+		IFNULL(sum(tx_count), 0) as tx_count`)
+	if startTime != nilTime && endTime != nilTime {
 		db = db.Where("stat_type = ? and stat_time >= ? and stat_time < ?", statType, startTime, endTime)
 	}
-	if startTime != nil && endTime == nil {
+	if startTime != nilTime && endTime == nilTime {
 		db = db.Where("stat_type = ? and stat_time >= ?", statType, startTime)
 	}
-	if startTime == nil && endTime != nil {
+	if startTime == nilTime && endTime != nilTime {
 		db = db.Where("stat_type = ? and stat_time < ?", statType, endTime)
 	}