data: actions destribution

Author: Developerayo

Diff for: api/transaction.go

@@ -172,6 +172,19 @@ func GetActionVolumesByName(db *sql.DB) gin.HandlerFunc {
 	}
 }
 
+func GetTotalActionCounts(db *sql.DB) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		totals, err := models.FetchActionVolumes(db)
+		if err != nil {
+			log.Printf("Error fetching action totals: %v", err)
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "Unable to retrieve action totals"})
+			return
+		}
+
+		c.JSON(http.StatusOK, totals)
+	}
+}
+
 // GetEstimatedFeeByActionType retrieves the estimated fee for a specific action type
 func GetEstimatedFeeByActionType(db *sql.DB) gin.HandlerFunc {
 	return func(c *gin.Context) {

Diff for: db/db.go

@@ -148,6 +148,12 @@ func CreateSchema(db *sql.DB) error {
     last_updated TIMESTAMP NOT NULL
 	);
 
+	CREATE TABLE IF NOT EXISTS action_volumes (
+    action_type SMALLINT PRIMARY KEY,
+    action_name TEXT NOT NULL,
+    total_count BIGINT NOT NULL DEFAULT 0
+	);
+
 	CREATE TABLE IF NOT EXISTS genesis_data (
 		id SERIAL PRIMARY KEY,
 		data JSON
@@ -178,6 +184,7 @@ func CreateSchema(db *sql.DB) error {
 	CREATE INDEX IF NOT EXISTS idx_daily_health_summaries_date ON daily_health_summaries(date);
 	CREATE INDEX IF NOT EXISTS idx_daily_health_summaries_state ON daily_health_summaries(state);
 	CREATE INDEX IF NOT EXISTS idx_daily_health_summaries_last_updated ON daily_health_summaries(last_updated);
+	CREATE INDEX IF NOT EXISTS idx_action_volumes_name ON action_volumes(action_name);
 
 	`
 

Diff for: docs/rest_api/transactions.md

@@ -336,6 +336,28 @@
 }
 ```
 
+## Get Total Action Destribution Counts
+
+- **Endpoint**: `/transactions/volumes/actions/total`
+- **Description**: Retrieves the all-time total count for each action type
+- **Example**: `curl http://localhost:8080/transactions/volumes/actions/total`
+- **Output**:
+
+```json
+[
+  {
+    "action_type": 0,
+    "action_name": "Transfer",
+    "total_count": 8350724
+  },
+  {
+    "action_type": 4,
+    "action_name": "CreateAsset",
+    "total_count": 37423
+  }
+]
+```
+
 ## Get Aggregated Estimated Fees for different Transactions
 
 - **Endpoint**: `/transactions/estimated_fee`

Diff for: main.go

@@ -68,7 +68,8 @@ func main() {
 	r.GET("/transactions/user/:user", api.GetTransactionsByUser(database))
 	r.GET("/transactions/volumes", api.GetAllActionVolumes(database))
 	r.GET("/transactions/volumes/:action_name", api.GetActionVolumesByName(database))
-	r.GET("/transactions/volumes/total", api.GetTotalTransferVolume(database))                               // Fetch transactions by user with pagination
+	r.GET("/transactions/volumes/actions/total", api.GetTotalActionCounts(database))                         // Fetch alltime actions volume
+	r.GET("/transactions/volumes/total", api.GetTotalTransferVolume(database))                               // Fetch alltime transfer volume
 	r.GET("/transactions/estimated_fee/action_type/:action_type", api.GetEstimatedFeeByActionType(database)) // Fetch estimated fee by action type
 	r.GET("/transactions/estimated_fee/action_name/:action_name", api.GetEstimatedFeeByActionName(database)) // Fetch estimated fee by action name
 	r.GET("/transactions/estimated_fee", api.GetAggregateEstimatedFees(database))                            // Fetch aggregate estimated fees

Diff for: models/transaction.go

@@ -16,18 +16,18 @@ import (
 )
 
 type Transaction struct {
-	ID        int                      `json:"ID"`
-	TxHash    string                   `json:"TxHash"`
-	BlockHash string                   `json:"BlockHash"`
-	BlockHeight int64                  `json:"BlockHeight"`
-	Sponsor   string                   `json:"Sponsor"`
-	Actors    []string                 `json:"Actors"`
-	Receivers []string                 `json:"Receivers"`
-	MaxFee    float64                  `json:"MaxFee"`
-	Success   bool                     `json:"Success"`
-	Fee       uint64                   `json:"Fee"`
-	Actions   []map[string]interface{} `json:"Actions"`
-	Timestamp string                   `json:"Timestamp"`
+	ID          int                      `json:"ID"`
+	TxHash      string                   `json:"TxHash"`
+	BlockHash   string                   `json:"BlockHash"`
+	BlockHeight int64                    `json:"BlockHeight"`
+	Sponsor     string                   `json:"Sponsor"`
+	Actors      []string                 `json:"Actors"`
+	Receivers   []string                 `json:"Receivers"`
+	MaxFee      float64                  `json:"MaxFee"`
+	Success     bool                     `json:"Success"`
+	Fee         uint64                   `json:"Fee"`
+	Actions     []map[string]interface{} `json:"Actions"`
+	Timestamp   string                   `json:"Timestamp"`
 }
 
 type TransactionVolumes struct {
@@ -51,6 +51,12 @@ type TotalVolume struct {
 	Total uint64 `json:"total"`
 }
 
+type ActionVolume struct {
+	ActionType uint8  `json:"action_type"`
+	ActionName string `json:"action_name"`
+	TotalCount int64  `json:"total_count"`
+}
+
 // CountFilteredTransactions counts transactions based on optional filters
 func CountFilteredTransactions(db *sql.DB, txHash, blockHash, actionType, actionName, user string) (int, error) {
 	query, args := buildTransactionFilterQuery("COUNT(*)", txHash, blockHash, actionType, actionName, user)
@@ -398,6 +404,32 @@ func FetchActionVolumesByName(db *sql.DB, actionName string) (ActionVolumes, err
 	return volume, nil
 }
 
+// FetchActionVolumes retrieves all action volumes
+func FetchActionVolumes(db *sql.DB) ([]ActionVolume, error) {
+	rows, err := db.Query(`
+        SELECT action_type, action_name, total_count
+        FROM action_volumes
+        ORDER BY total_count DESC`)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var totals []ActionVolume
+	for rows.Next() {
+		var total ActionVolume
+		if err := rows.Scan(
+			&total.ActionType,
+			&total.ActionName,
+			&total.TotalCount,
+		); err != nil {
+			return nil, err
+		}
+		totals = append(totals, total)
+	}
+	return totals, rows.Err()
+}
+
 // Helper function to scan transaction rows and unmarshal outputs
 func scanTransactions(rows *sql.Rows) ([]Transaction, error) {
 	var transactions []Transaction

Diff for: server/accept_block.go

@@ -187,6 +187,11 @@ func processBlockData(dbConn *sql.DB, executedBlock *chain.ExecutedBlock) error
 				log.Printf("Error saving action to database: %v\n", err)
 			}
 
+			// Update the action total
+			if err := updateActionVolume(dbConn, actionType, actionName); err != nil {
+				log.Printf("Error updating action total: %v\n", err)
+			}
+
 			// Handle special actions
 			// Parse actionInputJSON into map[string]interface{}
 			var actionInput map[string]interface{}

Diff for: server/process_actions.go

@@ -67,3 +67,14 @@ func processRegisterValidatorStakeID(dbConn *sql.DB, actionOutput map[string]int
 	)
 	return err
 }
+
+// Update the action volume in psql
+func updateActionVolume(db *sql.DB, actionType uint8, actionName string) error {
+	_, err := db.Exec(`
+        INSERT INTO action_volumes (action_type, action_name, total_count)
+        VALUES ($1, $2, 1)
+        ON CONFLICT (action_type) DO UPDATE
+        SET total_count = action_volumes.total_count + 1`,
+		actionType, actionName)
+	return err
+}