Merge pull request #67 from gaze-network/develop

Release v0.5.5
gaze-network · Oct 11, 2024 · e9ce8df · e9ce8df
2 parents 12985ae + 3ff73a9
commit e9ce8df
Show file tree

Hide file tree

Showing 8 changed files with 537 additions and 303 deletions.
diff --git a/modules/runes/database/postgresql/queries/data.sql b/modules/runes/database/postgresql/queries/data.sql
@@ -103,8 +103,7 @@ SELECT * FROM runes_entries
     @search::text = '' OR
     runes_entries.rune ILIKE '%' || @search::text || '%'
   )
-  ORDER BY (COALESCE(runes_entries.premine, 0) + COALESCE(runes_entries.terms_amount, 0) * COALESCE(states.mints, 0)) / 
-          (COALESCE(runes_entries.premine, 0) + COALESCE(runes_entries.terms_amount, 0) * COALESCE(runes_entries.terms_cap, 0))::float DESC
+  ORDER BY states.mints DESC
   LIMIT @_limit OFFSET @_offset;
 
 -- name: GetRuneIdFromRune :one
@@ -137,24 +136,24 @@ SELECT * FROM runes_transactions
 -- name: CountRuneEntries :one
 SELECT COUNT(*) FROM runes_entries;
 
--- name: CreateRuneEntry :exec
+-- name: CreateRuneEntries :batchexec
 INSERT INTO runes_entries (rune_id, rune, number, spacers, premine, symbol, divisibility, terms, terms_amount, terms_cap, terms_height_start, terms_height_end, terms_offset_start, terms_offset_end, turbo, etching_block, etching_tx_hash, etched_at)
   VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18);
 
--- name: CreateRuneEntryState :exec
+-- name: CreateRuneEntryStates :batchexec
 INSERT INTO runes_entry_states (rune_id, block_height, mints, burned_amount, completed_at, completed_at_height) VALUES ($1, $2, $3, $4, $5, $6);
 
--- name: CreateRuneTransaction :exec
+-- name: CreateRuneTransactions :batchexec
 INSERT INTO runes_transactions (hash, block_height, index, timestamp, inputs, outputs, mints, burns, rune_etched) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9);
 
--- name: CreateRunestone :exec
+-- name: CreateRunestones :batchexec
 INSERT INTO runes_runestones (tx_hash, block_height, etching, etching_divisibility, etching_premine, etching_rune, etching_spacers, etching_symbol, etching_terms, etching_terms_amount, etching_terms_cap, etching_terms_height_start, etching_terms_height_end, etching_terms_offset_start, etching_terms_offset_end, etching_turbo, edicts, mint, pointer, cenotaph, flaws) 
   VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21);
 
 -- name: CreateOutPointBalances :batchexec
 INSERT INTO runes_outpoint_balances (rune_id, pkscript, tx_hash, tx_idx, amount, block_height, spent_height) VALUES ($1, $2, $3, $4, $5, $6, $7);
 
--- name: SpendOutPointBalances :exec
+-- name: SpendOutPointBalancesBatch :batchexec
 UPDATE runes_outpoint_balances SET spent_height = $1 WHERE tx_hash = $2 AND tx_idx = $3;
 
 -- name: CreateRuneBalanceAtBlock :batchexec

diff --git a/modules/runes/datagateway/runes.go b/modules/runes/datagateway/runes.go
@@ -65,12 +65,12 @@ type RunesReaderDataGateway interface {
 }
 
 type RunesWriterDataGateway interface {
-	CreateRuneEntry(ctx context.Context, entry *runes.RuneEntry, blockHeight uint64) error
-	CreateRuneEntryState(ctx context.Context, entry *runes.RuneEntry, blockHeight uint64) error
+	CreateRuneEntries(ctx context.Context, entries []*runes.RuneEntry, blockHeight uint64) error
+	CreateRuneEntryStates(ctx context.Context, entries []*runes.RuneEntry, blockHeight uint64) error
 	CreateOutPointBalances(ctx context.Context, outPointBalances []*entity.OutPointBalance) error
-	SpendOutPointBalances(ctx context.Context, outPoint wire.OutPoint, blockHeight uint64) error
+	SpendOutPointBalancesBatch(ctx context.Context, outPoints []wire.OutPoint, blockHeight uint64) error
 	CreateRuneBalances(ctx context.Context, params []CreateRuneBalancesParams) error
-	CreateRuneTransaction(ctx context.Context, tx *entity.RuneTransaction) error
+	CreateRuneTransactions(ctx context.Context, txs []*entity.RuneTransaction) error
 	CreateIndexedBlock(ctx context.Context, block *entity.IndexedBlock) error
 
 	// TODO: collapse these into a single function (ResetStateToHeight)?

diff --git a/modules/runes/processor.go b/modules/runes/processor.go
@@ -145,7 +145,10 @@ func (p *Processor) ensureGenesisRune(ctx context.Context, network common.Networ
 			EtchingTxHash:     genesisRuneConfig.EtchingTxHash,
 			EtchedAt:          genesisRuneConfig.EtchedAt,
 		}
-		if err := p.runesDg.CreateRuneEntry(ctx, runeEntry, genesisRuneConfig.RuneId.BlockHeight); err != nil {
+		if err := p.runesDg.CreateRuneEntries(ctx, []*runes.RuneEntry{runeEntry}, genesisRuneConfig.RuneId.BlockHeight); err != nil {
+			return errors.Wrap(err, "failed to create genesis rune entry")
+		}
+		if err := p.runesDg.CreateRuneEntryStates(ctx, []*runes.RuneEntry{runeEntry}, genesisRuneConfig.RuneId.BlockHeight); err != nil {
 			return errors.Wrap(err, "failed to create genesis rune entry")
 		}
 	}

diff --git a/modules/runes/processor_process.go b/modules/runes/processor_process.go
@@ -27,19 +27,26 @@ import (
 func (p *Processor) Process(ctx context.Context, blocks []*types.Block) error {
 	for _, block := range blocks {
 		ctx := logger.WithContext(ctx, slog.Int64("height", block.Header.Height))
-		logger.DebugContext(ctx, "Processing new block", slog.Int("txs", len(block.Transactions)))
+		logger.InfoContext(ctx, "Processing new block",
+			slogx.String("event", "runes_processor_processing_block"),
+			slog.Int("txs", len(block.Transactions)),
+		)
 
+		start := time.Now()
 		for _, tx := range block.Transactions {
 			if err := p.processTx(ctx, tx, block.Header); err != nil {
 				return errors.Wrap(err, "failed to process tx")
 			}
 		}
+		timeTakenToProcess := time.Since(start)
+		logger.InfoContext(ctx, "Processed block",
+			slogx.String("event", "runes_processor_processed_block"),
+			slog.Duration("time_taken", timeTakenToProcess),
+		)
 
 		if err := p.flushBlock(ctx, block.Header); err != nil {
 			return errors.Wrap(err, "failed to flush block")
 		}
-
-		logger.DebugContext(ctx, "Inserted new block")
 	}
 	return nil
 }
@@ -669,6 +676,7 @@ func (p *Processor) getRunesBalancesAtOutPoint(ctx context.Context, outPoint wir
 }
 
 func (p *Processor) flushBlock(ctx context.Context, blockHeader types.BlockHeader) error {
+	start := time.Now()
 	runesDgTx, err := p.runesDg.BeginRunesTx(ctx)
 	if err != nil {
 		return errors.Wrap(err, "failed to begin runes tx")
@@ -715,78 +723,82 @@ func (p *Processor) flushBlock(ctx context.Context, blockHeader types.BlockHeade
 		return errors.Wrap(err, "failed to create indexed block")
 	}
 	// flush new rune entries
-	{
-		for _, runeEntry := range p.newRuneEntries {
-			if err := runesDgTx.CreateRuneEntry(ctx, runeEntry, uint64(blockHeader.Height)); err != nil {
-				return errors.Wrap(err, "failed to create rune entry")
-			}
-		}
-		p.newRuneEntries = make(map[runes.RuneId]*runes.RuneEntry)
+	newRuneEntries := lo.Values(p.newRuneEntries)
+	if err := runesDgTx.CreateRuneEntries(ctx, newRuneEntries, uint64(blockHeader.Height)); err != nil {
+		return errors.Wrap(err, "failed to create rune entry")
 	}
+	p.newRuneEntries = make(map[runes.RuneId]*runes.RuneEntry)
+
 	// flush new rune entry states
-	{
-		for _, runeEntry := range p.newRuneEntryStates {
-			if err := runesDgTx.CreateRuneEntryState(ctx, runeEntry, uint64(blockHeader.Height)); err != nil {
-				return errors.Wrap(err, "failed to create rune entry state")
-			}
-		}
-		p.newRuneEntryStates = make(map[runes.RuneId]*runes.RuneEntry)
+	newRuneEntryStates := lo.Values(p.newRuneEntryStates)
+	if err := runesDgTx.CreateRuneEntryStates(ctx, newRuneEntryStates, uint64(blockHeader.Height)); err != nil {
+		return errors.Wrap(err, "failed to create rune entry state")
 	}
+	p.newRuneEntryStates = make(map[runes.RuneId]*runes.RuneEntry)
+
 	// flush new outpoint balances
-	{
-		newBalances := make([]*entity.OutPointBalance, 0)
-		for _, balances := range p.newOutPointBalances {
-			newBalances = append(newBalances, balances...)
-		}
-		if err := runesDgTx.CreateOutPointBalances(ctx, newBalances); err != nil {
-			return errors.Wrap(err, "failed to create outpoint balances")
-		}
-		p.newOutPointBalances = make(map[wire.OutPoint][]*entity.OutPointBalance)
+	newBalances := make([]*entity.OutPointBalance, 0)
+	for _, balances := range p.newOutPointBalances {
+		newBalances = append(newBalances, balances...)
 	}
+	if err := runesDgTx.CreateOutPointBalances(ctx, newBalances); err != nil {
+		return errors.Wrap(err, "failed to create outpoint balances")
+	}
+	p.newOutPointBalances = make(map[wire.OutPoint][]*entity.OutPointBalance)
+
 	// flush new spend outpoints
-	{
-		for _, outPoint := range p.newSpendOutPoints {
-			if err := runesDgTx.SpendOutPointBalances(ctx, outPoint, uint64(blockHeader.Height)); err != nil {
-				return errors.Wrap(err, "failed to create spend outpoint")
-			}
-		}
-		p.newSpendOutPoints = make([]wire.OutPoint, 0)
+	newSpendOutPoints := p.newSpendOutPoints
+	if err := runesDgTx.SpendOutPointBalancesBatch(ctx, newSpendOutPoints, uint64(blockHeader.Height)); err != nil {
+		return errors.Wrap(err, "failed to create spend outpoint")
 	}
+	p.newSpendOutPoints = make([]wire.OutPoint, 0)
+
 	// flush new balances
-	{
-		params := make([]datagateway.CreateRuneBalancesParams, 0)
-		for pkScriptStr, balances := range p.newBalances {
-			pkScript, err := hex.DecodeString(pkScriptStr)
-			if err != nil {
-				return errors.Wrap(err, "failed to decode pk script")
-			}
-			for runeId, balance := range balances {
-				params = append(params, datagateway.CreateRuneBalancesParams{
-					PkScript:    pkScript,
-					RuneId:      runeId,
-					Balance:     balance,
-					BlockHeight: uint64(blockHeader.Height),
-				})
-			}
+	params := make([]datagateway.CreateRuneBalancesParams, 0)
+	for pkScriptStr, balances := range p.newBalances {
+		pkScript, err := hex.DecodeString(pkScriptStr)
+		if err != nil {
+			return errors.Wrap(err, "failed to decode pk script")
 		}
-		if err := runesDgTx.CreateRuneBalances(ctx, params); err != nil {
-			return errors.Wrap(err, "failed to create balances at block")
+		for runeId, balance := range balances {
+			params = append(params, datagateway.CreateRuneBalancesParams{
+				PkScript:    pkScript,
+				RuneId:      runeId,
+				Balance:     balance,
+				BlockHeight: uint64(blockHeader.Height),
+			})
 		}
-		p.newBalances = make(map[string]map[runes.RuneId]uint128.Uint128)
 	}
+	if err := runesDgTx.CreateRuneBalances(ctx, params); err != nil {
+		return errors.Wrap(err, "failed to create balances at block")
+	}
+	p.newBalances = make(map[string]map[runes.RuneId]uint128.Uint128)
+
 	// flush new rune transactions
-	{
-		for _, runeTx := range p.newRuneTxs {
-			if err := runesDgTx.CreateRuneTransaction(ctx, runeTx); err != nil {
-				return errors.Wrap(err, "failed to create rune transaction")
-			}
-		}
-		p.newRuneTxs = make([]*entity.RuneTransaction, 0)
+	newRuneTxs := p.newRuneTxs
+	if err := runesDgTx.CreateRuneTransactions(ctx, newRuneTxs); err != nil {
+		return errors.Wrap(err, "failed to create rune transaction")
 	}
+	p.newRuneTxs = make([]*entity.RuneTransaction, 0)
 
 	if err := runesDgTx.Commit(ctx); err != nil {
 		return errors.Wrap(err, "failed to commit runes tx")
 	}
+	timeTaken := time.Since(start)
+	logger.InfoContext(ctx, "Flushed block",
+		slogx.String("event", "runes_processor_flushed_block"),
+		slog.Int64("height", blockHeader.Height),
+		slog.String("hash", blockHeader.Hash.String()),
+		slog.String("event_hash", hex.EncodeToString(eventHash[:])),
+		slog.String("cumulative_event_hash", hex.EncodeToString(cumulativeEventHash[:])),
+		slog.Int("new_rune_entries", len(newRuneEntries)),
+		slog.Int("new_rune_entry_states", len(newRuneEntryStates)),
+		slog.Int("new_outpoint_balances", len(newBalances)),
+		slog.Int("new_spend_outpoints", len(newSpendOutPoints)),
+		slog.Int("new_balances", len(params)),
+		slog.Int("new_rune_txs", len(newRuneTxs)),
+		slogx.Duration("time_taken", timeTaken),
+	)
 
 	// submit event to reporting system
 	if p.reportingClient != nil {