feat: support s3 downloading configure

.dockerignore

@@ -1,18 +0,0 @@
-.git
-.gitignore
-.github
-.vscode
-**/*.md
-**/*.log
-.DS_Store
-
-# Docker
-Dockerfile
-.dockerignore
-docker-compose.yml
-
-# Go
-.golangci.yaml
-cmd.local
-config.*.y*ml
-config.y*ml

.github/workflows/code-analysis.yml

@@ -58,9 +58,6 @@ jobs:
           cache: true # caching and restoring go modules and build outputs.
       - run: echo "GOVERSION=$(go version)" >> $GITHUB_ENV
 
-      - name: Touch test result file
-        run: echo "" > test_output.json
-
       - name: Build
         run: go build -v ./...
 

.github/workflows/sqlc-verify.yml

@@ -22,7 +22,7 @@ jobs:
       - name: Setup Sqlc
         uses: sqlc-dev/setup-sqlc@v4
         with:
-          sqlc-version: "1.27.0"
+          sqlc-version: "1.26.0"
 
       - name: Check Diff
         run: sqlc diff

.golangci.yaml

@@ -101,6 +101,3 @@ linters-settings:
     attr-only: true
     key-naming-case: snake
     args-on-sep-lines: true
-  gosec:
-    excludes:
-      - G115

.vscode/settings.json

@@ -39,7 +39,7 @@
     "ui.completion.usePlaceholders": false,
     "ui.diagnostic.analyses": {
       // https://github.com/golang/tools/blob/master/gopls/doc/analyzers.md
-      "fieldalignment": false,
+      // "fieldalignment": false,
       "nilness": true,
       "shadow": false,
       "unusedparams": true,

Dockerfile

@@ -3,15 +3,15 @@ FROM golang:1.22 as builder
 WORKDIR /app
 
 COPY go.mod go.sum ./
-RUN --mount=type=cache,target=/go/pkg/mod/ go mod download
+RUN go mod download
 
 COPY ./ ./
 
 ENV GOOS=linux
 ENV CGO_ENABLED=0
 
-RUN --mount=type=cache,target=/go/pkg/mod/ \
-    go build -o main ./main.go
+RUN go build \
+          -o main ./main.go
 
 FROM alpine:latest
 
@@ -19,10 +19,9 @@ WORKDIR /app
 
 RUN apk --no-cache add ca-certificates tzdata
 
+
 COPY --from=builder /app/main .
-COPY --from=builder /app/modules ./modules
 
-# You can set TZ identifier to change the timezone, See https://en.wikipedia.org/wiki/List_of_tz_database_time_zones#List
-# ENV TZ=US/Central
+# You can set `TZ` environment variable to change the timezone
 
-ENTRYPOINT ["/app/main"]
+CMD ["/app/main", "run"]

README.md

@@ -1,10 +1,8 @@
 <!-- omit from toc -->
 
-- [Türkçe](https://github.com/Rumeyst/gaze-indexer/blob/turkish-translation/docs/README_tr.md)
-
 # Gaze Indexer
 
-Gaze Indexer is an open-source and modular indexing client for Bitcoin meta-protocols with **Unified Consistent APIs** across fungible token protocols.
+Gaze Indexer is an open-source and modular indexing client for Bitcoin meta-protocols. It has support for Runes out of the box, with **Unified Consistent APIs** across fungible token protocols.
 
 Gaze Indexer is built with **modularity** in mind, allowing users to run all modules in one monolithic instance with a single command, or as a distributed cluster of micro-services.
 
@@ -27,7 +25,7 @@ This allows developers to focus on what **truly** matters: Meta-protocol indexin
 ### 1. Runes
 
 The Runes Indexer is our first meta-protocol indexer. It indexes Runes states, transactions, runestones, and balances using Bitcoin transactions.
-It comes with a set of APIs for querying historical Runes data. See our [API Reference](https://api-docs.gaze.network) for full details.
+It comes with a set of APIs for querying historical Runes data. See our [API Reference](https://documenter.getpostman.com/view/28396285/2sA3Bn7Cxr) for full details.
 
 ## Installation
 
@@ -53,6 +51,8 @@ Here is our minimum database disk space requirement for each module.
 | ------ | -------------------------- | ---------------------------- |
 | Runes  | 10 GB                      | 150 GB                       |
 
+Here is our minimum database disk space requirement for each module.
+
 #### 4. Prepare `config.yaml` file.
 
 ```yaml
@@ -88,7 +88,7 @@ modules:
   # Configuration options for Runes module. Can be removed if not used.
   runes:
     database: "postgres" # Database to store Runes data. current supported databases: "postgres"
-    datasource: "bitcoin-node" # Data source to be used for Bitcoin data. current supported data sources: "bitcoin-node".
+    datasource: "database" # Data source to be used for Bitcoin data. current supported data sources: "bitcoin-node".
     api_handlers: # API handlers to enable. current supported handlers: "http"
       - http
     postgres:
@@ -108,14 +108,14 @@ We will be using `docker-compose` for our installation guide. Make sure the `doc
 # docker-compose.yaml
 services:
   gaze-indexer:
-    image: ghcr.io/gaze-network/gaze-indexer:v0.2.1
+    image: ghcr.io/gaze-network/gaze-indexer:v1.0.0
     container_name: gaze-indexer
     restart: unless-stopped
     ports:
       - 8080:8080 # Expose HTTP server port to host
     volumes:
       - "./config.yaml:/app/config.yaml" # mount config.yaml file to the container as "/app/config.yaml"
-    command: ["/app/main", "run", "--modules", "runes"] # Put module flags after "run" commands to select which modules to run.
+    command: ["/app/main", "run", "--runes"] # Put module flags after "run" commands to select which modules to run.
 ```
 
 ### Install from source

cmd/cmd_run.go

@@ -17,21 +17,15 @@ import (
 	"github.com/gaze-network/indexer-network/common/errs"
 	"github.com/gaze-network/indexer-network/core/indexer"
 	"github.com/gaze-network/indexer-network/internal/config"
-	"github.com/gaze-network/indexer-network/modules/nodesale"
 	"github.com/gaze-network/indexer-network/modules/runes"
 	"github.com/gaze-network/indexer-network/pkg/automaxprocs"
+	"github.com/gaze-network/indexer-network/pkg/errorhandler"
 	"github.com/gaze-network/indexer-network/pkg/logger"
 	"github.com/gaze-network/indexer-network/pkg/logger/slogx"
-	"github.com/gaze-network/indexer-network/pkg/middleware/errorhandler"
-	"github.com/gaze-network/indexer-network/pkg/middleware/requestcontext"
-	"github.com/gaze-network/indexer-network/pkg/middleware/requestlogger"
 	"github.com/gaze-network/indexer-network/pkg/reportingclient"
 	"github.com/gofiber/fiber/v2"
 	"github.com/gofiber/fiber/v2/middleware/compress"
-	"github.com/gofiber/fiber/v2/middleware/cors"
-	"github.com/gofiber/fiber/v2/middleware/favicon"
 	fiberrecover "github.com/gofiber/fiber/v2/middleware/recover"
-	"github.com/gofiber/fiber/v2/middleware/requestid"
 	"github.com/samber/do/v2"
 	"github.com/samber/lo"
 	"github.com/spf13/cobra"
@@ -40,7 +34,6 @@ import (
 // Register Modules
 var Modules = do.Package(
 	do.LazyNamed("runes", runes.New),
-	do.LazyNamed("nodesale", nodesale.New),
 )
 
 func NewRunCommand() *cobra.Command {
@@ -138,26 +131,10 @@ func runHandler(cmd *cobra.Command, _ []string) error {
 	// Initialize HTTP server
 	do.Provide(injector, func(i do.Injector) (*fiber.App, error) {
 		app := fiber.New(fiber.Config{
-			AppName: "Gaze Indexer",
-			ErrorHandler: func(c *fiber.Ctx, err error) error {
-				logger.ErrorContext(c.UserContext(), "Something went wrong, unhandled api error",
-					slogx.String("event", "api_unhandled_error"),
-					slogx.Error(err),
-				)
-				return errors.WithStack(c.Status(http.StatusInternalServerError).JSON(fiber.Map{
-					"error": "Internal Server Error",
-				}))
-			},
+			AppName:      "Gaze Indexer",
+			ErrorHandler: errorhandler.NewHTTPErrorHandler(),
 		})
 		app.
-			Use(favicon.New()).
-			Use(cors.New()).
-			Use(requestid.New()).
-			Use(requestcontext.New(
-				requestcontext.WithRequestId(),
-				requestcontext.WithClientIP(conf.HTTPServer.RequestIP),
-			)).
-			Use(requestlogger.New(conf.HTTPServer.Logger)).
 			Use(fiberrecover.New(fiberrecover.Config{
 				EnableStackTrace: true,
 				StackTraceHandler: func(c *fiber.Ctx, e interface{}) {
@@ -166,7 +143,6 @@ func runHandler(cmd *cobra.Command, _ []string) error {
 					logger.ErrorContext(c.UserContext(), "Something went wrong, panic in http handler", slogx.Any("panic", e), slog.String("stacktrace", string(buf)))
 				},
 			})).
-			Use(errorhandler.New()).
 			Use(compress.New(compress.Config{
 				Level: compress.LevelDefault,
 			}))

cmd/cmd_version.go

@@ -6,15 +6,13 @@ import (
 	"github.com/cockroachdb/errors"
 	"github.com/gaze-network/indexer-network/common/errs"
 	"github.com/gaze-network/indexer-network/core/constants"
-	"github.com/gaze-network/indexer-network/modules/nodesale"
-	runesconstants "github.com/gaze-network/indexer-network/modules/runes/constants"
+	"github.com/gaze-network/indexer-network/modules/runes"
 	"github.com/spf13/cobra"
 )
 
 var versions = map[string]string{
-	"":         constants.Version,
-	"runes":    runesconstants.Version,
-	"nodesale": nodesale.Version,
+	"":      constants.Version,
+	"runes": runes.Version,
 }
 
 type versionCmdOptions struct {

common/bitcoin.go

@@ -0,0 +1,4 @@
+package common
+
+// HalvingInterval is the number of blocks between each halving event.
+const HalvingInterval = 210_000

common/errs/errs.go

@@ -24,9 +24,6 @@ var (
 	// Skippable is returned when got an error but it can be skipped or ignored and continue
 	Skippable = errors.NewWithDepth(depth, "skippable")
 
-	// Retryable is returned when got an error but it can be retried
-	Retryable = errors.NewWithDepth(depth, "retryable")
-
 	// Unsupported is returned when a feature or result is not supported
 	Unsupported = errors.NewWithDepth(depth, "unsupported")
 

common/network.go

@@ -1,31 +1,22 @@
 package common
 
-import (
-	"github.com/btcsuite/btcd/chaincfg"
-	"github.com/gaze-network/indexer-network/pkg/logger"
-)
+import "github.com/btcsuite/btcd/chaincfg"
 
 type Network string
 
 const (
-	NetworkMainnet        Network = "mainnet"
-	NetworkTestnet        Network = "testnet"
-	NetworkFractalMainnet Network = "fractal-mainnet"
-	NetworkFractalTestnet Network = "fractal-testnet"
+	NetworkMainnet Network = "mainnet"
+	NetworkTestnet Network = "testnet"
 )
 
 var supportedNetworks = map[Network]struct{}{
-	NetworkMainnet:        {},
-	NetworkTestnet:        {},
-	NetworkFractalMainnet: {},
-	NetworkFractalTestnet: {},
+	NetworkMainnet: {},
+	NetworkTestnet: {},
 }
 
 var chainParams = map[Network]*chaincfg.Params{
-	NetworkMainnet:        &chaincfg.MainNetParams,
-	NetworkTestnet:        &chaincfg.TestNet3Params,
-	NetworkFractalMainnet: &chaincfg.MainNetParams,
-	NetworkFractalTestnet: &chaincfg.MainNetParams,
+	NetworkMainnet: &chaincfg.MainNetParams,
+	NetworkTestnet: &chaincfg.TestNet3Params,
 }
 
 func (n Network) IsSupported() bool {
@@ -40,15 +31,3 @@ func (n Network) ChainParams() *chaincfg.Params {
 func (n Network) String() string {
 	return string(n)
 }
-
-func (n Network) HalvingInterval() uint64 {
-	switch n {
-	case NetworkMainnet, NetworkTestnet:
-		return 210_000
-	case NetworkFractalMainnet, NetworkFractalTestnet:
-		return 2_100_000
-	default:
-		logger.Panic("invalid network")
-		return 0
-	}
-}

config.example.yaml

@@ -23,14 +23,6 @@ reporting:
 # HTTP server configuration options.
 http_server:
   port: 8080 # Port to run the HTTP server on for modules with HTTP API handlers.
-  logger:
-    disable: false # disable logger if logger level is `INFO`
-    request_header: false
-    request_query: false
-  requestip: # Client IP extraction configuration options. This is unnecessary if you don't care about the real client IP or if you're not using a reverse proxy.
-    trusted_proxies_ip: # Cloudflare, GCP Public LB. See: server/internal/middleware/requestcontext/PROXY-IP.md
-    trusted_proxies_header: # X-Real-IP, CF-Connecting-IP
-    enable_reject_malformed_request: false # return 403 if request is malformed (invalid IP)
 
 # Meta-protocol modules configuration options.
 modules:
@@ -47,11 +39,3 @@ modules:
       password: "password"
       db_name: "postgres"
       # url: "postgres://postgres:password@localhost:5432/postgres?sslmode=prefer" # [Optional] This will override other database credentials above.
-  nodesale:
-    postgres:
-      host: "localhost"
-      port: 5432
-      user: "postgres"
-      password: "P@ssw0rd"
-      db_name: "postgres"
-    last_block_default: 400

core/constants/constants.go

@@ -1,5 +1,5 @@
 package constants
 
 const (
-	Version = "v0.2.1"
+	Version = "v0.0.1"
 )

core/datasources/aws_public_data.go

@@ -0,0 +1,688 @@
+// AWS Public Blockchain Datasource
+// - https://registry.opendata.aws/aws-public-blockchain
+// - https://github.com/aws-solutions-library-samples/guidance-for-digital-assets-on-aws
+//
+// To setup your own data source, see: https://github.com/aws-solutions-library-samples/guidance-for-digital-assets-on-aws/blob/main/analytics/producer/README.md
+package datasources
+
+import (
+	"cmp"
+	"context"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"log/slog"
+	"math"
+	"slices"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/config"
+	"github.com/aws/aws-sdk-go-v2/feature/s3/manager"
+	"github.com/aws/aws-sdk-go-v2/service/s3"
+	s3types "github.com/aws/aws-sdk-go-v2/service/s3/types"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/wire"
+	"github.com/cockroachdb/errors"
+	"github.com/gaze-network/indexer-network/common"
+	"github.com/gaze-network/indexer-network/common/errs"
+	"github.com/gaze-network/indexer-network/core/types"
+	"github.com/gaze-network/indexer-network/internal/subscription"
+	"github.com/gaze-network/indexer-network/pkg/btcutils"
+	"github.com/gaze-network/indexer-network/pkg/logger"
+	"github.com/gaze-network/indexer-network/pkg/logger/slogx"
+	"github.com/gaze-network/indexer-network/pkg/parquetutils"
+	"github.com/samber/lo"
+	parquettypes "github.com/xitongsys/parquet-go/types"
+	"golang.org/x/sync/errgroup"
+)
+
+const (
+	awsPublicDataS3Region = "us-east-2"
+	awsPublicDataS3Bucket = "aws-public-blockchain"
+
+	defaultAWSPublicDataDownloadConcurrency = 8
+)
+
+var firstBitcoinTimestamp = time.Date(2009, time.January, 3, 18, 15, 5, 0, time.UTC)
+
+// Make sure to implement the BitcoinDatasource interface
+var _ Datasource[*types.Block] = (*AWSPublicDataDatasource)(nil)
+
+type AWSPublicDataDatasourceConfig struct {
+	// The number of goroutines to spin up in parallel when downloading parts.
+	// Concurrency of 1 will download the parts sequentially.
+	// Default is 8.
+	//
+	// CAUTION: High concurrency with low part size can reduce the time to download file,
+	// but it can also increase the memory usage.
+	DownloadConcurrency int
+
+	// The size (in bytes) to request from S3 for each part.
+	// Default is depend on the concurrency and file size (part size = file size / concurrency).
+	//
+	// CAUTION: High concurrency with low part size can reduce the time to download file,
+	// but it can also increase the memory usage.
+	DownloadPartSize int64 `mapstructure:"download_part_size"`
+}
+
+type AWSPublicDataDatasource struct {
+	btcDatasource Datasource[*types.Block]
+	s3Client      *s3.Client
+	s3Bucket      string
+	config        AWSPublicDataDatasourceConfig
+}
+
+func NewAWSPublicData(btcDatasource Datasource[*types.Block], conf AWSPublicDataDatasourceConfig) *AWSPublicDataDatasource {
+	sdkConfig, err := config.LoadDefaultConfig(context.Background())
+	if err != nil {
+		logger.Panic("Can't load AWS SDK user config", slogx.Error(err), slog.String("package", "datasources"))
+	}
+
+	// TODO: support user defined config (self-hosted s3 bucket)
+	s3client := s3.NewFromConfig(sdkConfig, func(o *s3.Options) {
+		o.Region = awsPublicDataS3Region
+		o.Credentials = aws.AnonymousCredentials{}
+	})
+
+	if conf.DownloadConcurrency <= 0 {
+		conf.DownloadConcurrency = defaultAWSPublicDataDownloadConcurrency
+	}
+
+	return &AWSPublicDataDatasource{
+		btcDatasource: btcDatasource,
+		s3Client:      s3client,
+		s3Bucket:      awsPublicDataS3Bucket,
+		config:        conf,
+	}
+}
+
+func (d AWSPublicDataDatasource) Name() string {
+	return fmt.Sprintf("aws_public_data/%s", d.btcDatasource.Name())
+}
+
+func (d *AWSPublicDataDatasource) Fetch(ctx context.Context, from, to int64) ([]*types.Block, error) {
+	ch := make(chan []*types.Block)
+	subscription, err := d.FetchAsync(ctx, from, to, ch)
+	if err != nil {
+		return nil, errors.WithStack(err)
+	}
+	defer subscription.Unsubscribe()
+
+	blocks := make([]*types.Block, 0)
+	for {
+		select {
+		case b, ok := <-ch:
+			if !ok {
+				return blocks, nil
+			}
+			blocks = append(blocks, b...)
+		case <-subscription.Done():
+			if err := ctx.Err(); err != nil {
+				return nil, errors.Wrap(err, "context done")
+			}
+			return blocks, nil
+		case err := <-subscription.Err():
+			if err != nil {
+				return nil, errors.Wrap(err, "got error while fetch async")
+			}
+			return blocks, nil
+		case <-ctx.Done():
+			return nil, errors.Wrap(ctx.Err(), "context done")
+		}
+	}
+}
+
+func (d *AWSPublicDataDatasource) FetchAsync(ctx context.Context, from, to int64, ch chan<- []*types.Block) (*subscription.ClientSubscription[[]*types.Block], error) {
+	ctx = logger.WithContext(ctx,
+		slogx.String("package", "datasources"),
+		slogx.String("datasource", d.Name()),
+	)
+
+	start, end, skip, err := d.prepareRange(ctx, from, to)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to prepare fetch range")
+	}
+
+	subscription := subscription.NewSubscription(ch)
+	if skip {
+		if err := subscription.UnsubscribeWithContext(ctx); err != nil {
+			return nil, errors.Wrap(err, "failed to unsubscribe")
+		}
+		return subscription.Client(), nil
+	}
+
+	startFiles, err := d.listBlocksFilesByDate(ctx, start.Timestamp)
+	if err != nil {
+		if err := subscription.UnsubscribeWithContext(ctx); err != nil {
+			return nil, errors.Wrap(err, "failed to unsubscribe")
+		}
+		return nil, errors.Wrap(err, "failed to list files by date")
+	}
+
+	// supported only merged blocks files
+	startFiles = lo.Filter(startFiles, func(file awsFile, _ int) bool {
+		return strings.Contains(file.Key, "part-")
+	})
+
+	// use other datasource instead of s3 if there's no supported data
+	if len(startFiles) == 0 {
+		if err := subscription.UnsubscribeWithContext(ctx); err != nil {
+			return nil, errors.Wrap(err, "failed to unsubscribe")
+		}
+		s, err := d.btcDatasource.FetchAsync(ctx, start.Height, end.Height, ch)
+		return s, errors.WithStack(err)
+	}
+
+	go func() {
+		defer func() {
+			// add a bit delay to prevent shutdown before client receive all blocks
+			time.Sleep(100 * time.Millisecond)
+
+			subscription.Unsubscribe()
+		}()
+		// loop through each day until reach the end of supported data or within end block date
+		for ts := start.Timestamp; ts.Before(end.Timestamp.Round(24*time.Hour)) && ts.Before(time.Now()); ts = ts.Add(24 * time.Hour) {
+			ctx := logger.WithContext(ctx,
+				slogx.Time("date", ts),
+				slogx.Int64("date_unix", ts.Unix()),
+			)
+
+			logger.DebugContext(ctx, "Fetching data from AWS S3", slogx.Int64("start", start.Height), slogx.Int64("end", end.Height))
+
+			allBlocksFiles, err := d.listBlocksFilesByDate(ctx, ts)
+			if err != nil {
+				logger.ErrorContext(ctx, "Failed to list blocks files by date from aws s3", slogx.Error(err))
+				if err := subscription.SendError(ctx, errors.WithStack(err)); err != nil {
+					logger.WarnContext(ctx, "Failed to send datasource error to subscription client", slogx.Error(err))
+				}
+				return
+			}
+
+			allTxsFiles, err := d.listTxsFilesByDate(ctx, ts)
+			if err != nil {
+				logger.ErrorContext(ctx, "Failed to list txs files by date from aws s3", slogx.Error(err))
+				if err := subscription.SendError(ctx, errors.WithStack(err)); err != nil {
+					logger.WarnContext(ctx, "Failed to send datasource error to subscription client", slogx.Error(err))
+				}
+				return
+			}
+
+			blocksFiles := lo.Filter(allBlocksFiles, func(file awsFile, _ int) bool {
+				return strings.Contains(file.Key, "part-")
+			})
+			txsFiles := lo.Filter(allTxsFiles, func(file awsFile, _ int) bool {
+				return strings.Contains(file.Key, "part-")
+			})
+
+			logger.DebugContext(ctx, "Found files in AWS S3 bucket",
+				slogx.Int("files_blocks", len(allBlocksFiles)),
+				slogx.Int("files_blocks_merged", len(blocksFiles)),
+				slogx.Int("files_txs_all", len(allTxsFiles)),
+				slogx.Int("files_txs_merged", len(txsFiles)),
+			)
+
+			// Reach the end of supported data,
+			// stop fetching data from AWS S3
+			if len(blocksFiles) == 0 || len(txsFiles) == 0 {
+				logger.DebugContext(ctx, "No blocks files found, stop fetching data from AWS S3")
+				return
+			}
+
+			// prevent unexpected error
+			{
+				if len(blocksFiles) != 1 {
+					logger.ErrorContext(ctx, "Unexpected blocks files count, should be 1", slogx.Int("count", len(blocksFiles)))
+					if err := subscription.SendError(ctx, errors.Wrap(errs.InternalError, "unexpected blocks files count")); err != nil {
+						logger.WarnContext(ctx, "Failed to send datasource error to subscription client", slogx.Error(err))
+					}
+					return
+				}
+				if len(txsFiles) != 1 {
+					logger.ErrorContext(ctx, "Unexpected txs files count, should be 1", slogx.Int("count", len(txsFiles)))
+					if err := subscription.SendError(ctx, errors.Wrap(errs.InternalError, "unexpected txs files count")); err != nil {
+						logger.WarnContext(ctx, "Failed to send datasource error to subscription client", slogx.Error(err))
+					}
+					return
+				}
+			}
+
+			// TODO: use concurrent stream (max 2 goroutine) to download files then sequentially read parquet files
+			// to improve performance while not consuming too much memory (increase around 500 MB per goroutine)
+			var (
+				// TODO: create []byte pool to reduce alloc ops (reduce GC pressure)
+				// TODO: use FileSystem for default buffer (can choose memory or disk buffer)
+				blocksBuffer = parquetutils.NewBuffer()
+				txsBuffer    = parquetutils.NewBuffer()
+			)
+			startDownload := time.Now()
+			if err := d.downloadFile(ctx, blocksFiles[0], blocksBuffer); err != nil {
+				logger.ErrorContext(ctx, "Failed to download blocks file from AWS S3", slogx.Int("count", len(txsFiles)))
+				if err := subscription.SendError(ctx, errors.Wrap(err, "can't download blocks file")); err != nil {
+					logger.WarnContext(ctx, "Failed to send datasource error to subscription client", slogx.Error(err))
+				}
+			}
+			if err := d.downloadFile(ctx, txsFiles[0], txsBuffer); err != nil {
+				logger.ErrorContext(ctx, "Failed to download blocks file from AWS S3", slogx.Int("count", len(txsFiles)))
+				if err := subscription.SendError(ctx, errors.Wrap(err, "can't download blocks file")); err != nil {
+					logger.WarnContext(ctx, "Failed to send datasource error to subscription client", slogx.Error(err))
+				}
+			}
+			logger.DebugContext(ctx, "Downloaded files from AWS S3",
+				slogx.Duration("duration", time.Since(startDownload)),
+				slogx.Int("sizes_blocks", len(blocksBuffer.Bytes())),
+				slogx.Int("sizes_txs", len(txsBuffer.Bytes())),
+			)
+
+			// Read parquet files
+			startRead := time.Now()
+
+			// we can read all blocks data at once because it's small
+			rawAllBlocks, err := parquetutils.ReadAll[awsBlock](blocksBuffer)
+			if err != nil {
+				logger.ErrorContext(ctx, "Failed to read parquet blocks data", slogx.Error(err))
+				if err := subscription.SendError(ctx, errors.Wrap(err, "can't read parquet blocks data")); err != nil {
+					logger.WarnContext(ctx, "Failed to send datasource error to subscription client", slogx.Error(err))
+				}
+			}
+
+			// NOTE: We shouldn't read all txs data at once because it's very huge (up to ~1.5GB memory usage)
+			// we should read it by chunk and send it to subscription client to reduce memory usage.
+			// But AWS Public Dataset are not sorted by block number and index,
+			// so we can't avoid reading all transactions data by skip unnecessary transactions
+			// or chunk data by block number to reduce memory usage :(
+			rawAllTxs, err := parquetutils.ReadAll[awsTransaction](blocksBuffer)
+			if err != nil {
+				logger.ErrorContext(ctx, "Failed to read parquet txs data", slogx.Error(err))
+				if err := subscription.SendError(ctx, errors.Wrap(err, "can't read parquet blocks data")); err != nil {
+					logger.WarnContext(ctx, "Failed to send datasource error to subscription client", slogx.Error(err))
+				}
+			}
+
+			groupRawTxs := lo.GroupBy(rawAllTxs, func(tx awsTransaction) int64 {
+				return tx.BlockNumber
+			})
+
+			// filter blocks data by height range
+			rawFilteredBlocks := lo.Filter(rawAllBlocks, func(block awsBlock, _ int) bool {
+				return block.Number >= start.Height && block.Number <= end.Height
+			})
+			slices.SortFunc(rawFilteredBlocks, func(i, j awsBlock) int {
+				return cmp.Compare(i.Number, j.Number)
+			})
+
+			logger.DebugContext(ctx, "Read parquet files",
+				slogx.Duration("duration", time.Since(startRead)),
+				slogx.Int("total_blocks", len(rawAllBlocks)),
+				slogx.Int("filtered_blocks", len(rawFilteredBlocks)),
+				slogx.Int("total_txs", len(rawAllTxs)),
+				slogx.Int("total_txs_grouped", len(groupRawTxs)),
+			)
+
+			blocks := make([]*types.Block, 0, len(rawFilteredBlocks))
+			for _, rawBlock := range rawFilteredBlocks {
+				blockHeader, err := rawBlock.ToBlockHeader()
+				if err != nil {
+					logger.ErrorContext(ctx, "Failed to convert aws block to type block header", slogx.Error(err))
+					if err := subscription.SendError(ctx, errors.Wrap(err, "can't convert aws block to type block header")); err != nil {
+						logger.WarnContext(ctx, "Failed to send datasource error to subscription client", slogx.Error(err))
+					}
+					return
+				}
+
+				txs := make([]*types.Transaction, 0, len(groupRawTxs[blockHeader.Height]))
+				for _, rawTx := range groupRawTxs[rawBlock.Number] {
+					tx, err := rawTx.ToTransaction(rawBlock)
+					if err != nil {
+						logger.ErrorContext(ctx, "Failed to convert aws transaction to type transaction", slogx.Error(err))
+						if err := subscription.SendError(ctx, errors.Wrap(err, "can't convert aws transaction to type transaction")); err != nil {
+							logger.WarnContext(ctx, "Failed to send datasource error to subscription client", slogx.Error(err))
+						}
+						return
+					}
+					txs = append(txs, tx)
+				}
+				slices.SortFunc(txs, func(i, j *types.Transaction) int {
+					return cmp.Compare(i.Index, j.Index)
+				})
+
+				blocks = append(blocks, &types.Block{
+					Header:       blockHeader,
+					Transactions: txs,
+				})
+			}
+
+			logger.DebugContext(ctx, "Send blocks to subscription client", slogx.Int("count", len(blocks)))
+			if err := subscription.Send(ctx, blocks); err != nil {
+				if errors.Is(err, errs.Closed) {
+					logger.DebugContext(ctx, "Subscription client closed, can't send", slogx.Error(err))
+					return
+				}
+				logger.WarnContext(ctx, "Failed to send bitcoin blocks to subscription client",
+					slogx.Int64("start", blocks[0].Header.Height),
+					slogx.Int64("end", blocks[len(blocks)-1].Header.Height),
+					slogx.Error(err),
+				)
+			}
+		}
+	}()
+
+	return subscription.Client(), nil
+}
+
+func (d *AWSPublicDataDatasource) GetBlockHeader(ctx context.Context, height int64) (types.BlockHeader, error) {
+	header, err := d.btcDatasource.GetBlockHeader(ctx, height)
+	return header, errors.WithStack(err)
+}
+
+func (d *AWSPublicDataDatasource) GetCurrentBlockHeight(ctx context.Context) (int64, error) {
+	height, err := d.btcDatasource.GetCurrentBlockHeight(ctx)
+	return height, errors.WithStack(err)
+}
+
+func (d *AWSPublicDataDatasource) prepareRange(ctx context.Context, fromHeight, toHeight int64) (startHeader, endHeader types.BlockHeader, skip bool, err error) {
+	start := fromHeight
+	end := toHeight
+
+	// get current bitcoin block height
+	latestBlockHeight, err := d.btcDatasource.GetCurrentBlockHeight(ctx)
+	if err != nil {
+		return types.BlockHeader{}, types.BlockHeader{}, false, errors.Wrap(err, "failed to get block count")
+	}
+
+	// set start to genesis block height
+	if start < 0 {
+		start = 0
+	}
+
+	// set end to current bitcoin block height if
+	// - end is -1
+	// - end is greater that current bitcoin block height
+	if end < 0 || end > latestBlockHeight {
+		end = latestBlockHeight
+	}
+
+	// if start is greater than end, skip this round
+	if start > end {
+		return types.BlockHeader{}, types.BlockHeader{}, true, nil
+	}
+
+	if err != nil {
+		return types.BlockHeader{}, types.BlockHeader{}, false, errors.Wrapf(err, "block %v", end)
+	}
+
+	group, groupctx := errgroup.WithContext(ctx)
+	group.Go(func() error {
+		startHeader, err = d.GetBlockHeader(groupctx, start)
+		return errors.Wrapf(err, "block %v", start)
+	})
+	group.Go(func() error {
+		endHeader, err = d.GetBlockHeader(ctx, end)
+		return errors.Wrapf(err, "block %v", end)
+	})
+	if err := group.Wait(); err != nil {
+		return types.BlockHeader{}, types.BlockHeader{}, false, errors.Wrap(err, "failed to get block header")
+	}
+
+	return startHeader, endHeader, false, nil
+}
+
+func (d *AWSPublicDataDatasource) listFiles(ctx context.Context, prefix string) ([]awsFile, error) {
+	result, err := d.s3Client.ListObjectsV2(ctx, &s3.ListObjectsV2Input{
+		Bucket: aws.String(d.s3Bucket),
+		Prefix: aws.String(prefix),
+	})
+	if err != nil {
+		return nil, errors.Wrapf(err, "can't list s3 bucket objects for bucket %q and prefix %q", d.s3Bucket, prefix)
+	}
+
+	// filter empty keys
+	objs := lo.Filter(result.Contents, func(item s3types.Object, _ int) bool { return item.Key != nil })
+	return lo.Map(objs, func(item s3types.Object, _ int) awsFile {
+		return awsFile{
+			Key:          *item.Key,
+			Size:         *item.Size,
+			LastModified: *item.LastModified,
+		}
+	}), nil
+}
+
+func (d *AWSPublicDataDatasource) listBlocksFilesByDate(ctx context.Context, date time.Time) ([]awsFile, error) {
+	if date.Before(firstBitcoinTimestamp) {
+		return nil, errors.Wrapf(errs.InvalidArgument, "date %v is before first bitcoin timestamp %v", date, firstBitcoinTimestamp)
+	}
+	prefix := "v1.0/btc/blocks/date=" + date.UTC().Format(time.DateOnly)
+	files, err := d.listFiles(ctx, prefix)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to list blocks files by date")
+	}
+	return files, nil
+}
+
+func (d *AWSPublicDataDatasource) listTxsFilesByDate(ctx context.Context, date time.Time) ([]awsFile, error) {
+	if date.Before(firstBitcoinTimestamp) {
+		return nil, errors.Wrapf(errs.InvalidArgument, "date %v is before first bitcoin timestamp %v", date, firstBitcoinTimestamp)
+	}
+	prefix := "v1.0/btc/transactions/date=" + date.UTC().Format(time.DateOnly)
+	files, err := d.listFiles(ctx, prefix)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to list txs files by date")
+	}
+	return files, nil
+}
+
+func (d *AWSPublicDataDatasource) downloadFile(ctx context.Context, f awsFile, w io.WriterAt) error {
+	downloader := manager.NewDownloader(d.s3Client, func(md *manager.Downloader) {
+		md.Concurrency = d.config.DownloadConcurrency
+		md.PartSize = d.config.DownloadPartSize
+		if md.PartSize <= 0 {
+			md.PartSize = f.Size / int64(md.Concurrency)
+		}
+	})
+
+	numBytes, err := downloader.Download(ctx, w, &s3.GetObjectInput{
+		Bucket: aws.String(d.s3Bucket),
+		Key:    aws.String(f.Key),
+	})
+	if err != nil {
+		return errors.Wrapf(err, "failed to download file for bucket %q and key %q", d.s3Bucket, f.Key)
+	}
+
+	if numBytes < 1 {
+		return errors.Wrap(errs.NotFound, "got empty file")
+	}
+
+	return nil
+}
+
+// TODO: remove unused fields to reduce memory usage
+type (
+	awsBlock struct {
+		Hash              string `parquet:"name=hash, type=BYTE_ARRAY, convertedtype=UTF8, repetitiontype=OPTIONAL"`
+		Bits              string `parquet:"name=bits, type=BYTE_ARRAY, convertedtype=UTF8, repetitiontype=OPTIONAL"` // Hex string format
+		PreviousBlockHash string `parquet:"name=previousblockhash, type=BYTE_ARRAY, convertedtype=UTF8, repetitiontype=OPTIONAL"`
+		MerkleRoot        string `parquet:"name=merkle_root, type=BYTE_ARRAY, convertedtype=UTF8, repetitiontype=OPTIONAL"`
+		CoinbaseParam     string `parquet:"name=coinbase_param, type=BYTE_ARRAY, convertedtype=UTF8, repetitiontype=OPTIONAL"`
+		Timestamp         string `parquet:"name=timestamp, type=INT96, repetitiontype=OPTIONAL"`
+		Number            int64  `parquet:"name=number, type=INT64, repetitiontype=OPTIONAL"`
+		Version           int64  `parquet:"name=version, type=INT64, repetitiontype=OPTIONAL"`
+		Nonce             int64  `parquet:"name=nonce, type=INT64, repetitiontype=OPTIONAL"`
+		// MedianTime string `parquet:"name=mediantime, type=INT96, repetitiontype=OPTIONAL"`
+		// Difficulty float64 `parquet:"name=difficulty, type=DOUBLE, repetitiontype=OPTIONAL"`
+		// Chainwork         string  `parquet:"name=chainwork, type=BYTE_ARRAY, convertedtype=UTF8, repetitiontype=OPTIONAL"`
+		// Size              int64   `parquet:"name=size, type=INT64, repetitiontype=OPTIONAL"`
+		// Weight            int64   `parquet:"name=weight, type=INT64, repetitiontype=OPTIONAL"`
+		// TransactionCount  int64   `parquet:"name=transaction_count, type=INT64, repetitiontype=OPTIONAL"`
+		// StrippedSize      int64   `parquet:"name=stripped_size, type=INT64, repetitiontype=OPTIONAL"`
+		// Date              string  `parquet:"name=date, type=BYTE_ARRAY, convertedtype=UTF8, repetitiontype=OPTIONAL"`
+		// LastModified      string  `parquet:"name=last_modified, type=INT96, repetitiontype=OPTIONAL"`
+	}
+	awsTransaction struct {
+		Hash        string         `parquet:"name=hash, type=BYTE_ARRAY, convertedtype=UTF8, repetitiontype=OPTIONAL"`
+		BlockHash   string         `parquet:"name=block_hash, type=BYTE_ARRAY, convertedtype=UTF8, repetitiontype=OPTIONAL"`
+		Outputs     []*awsTxOutput `parquet:"name=outputs, type=LIST, repetitiontype=OPTIONAL, valuetype=STRUCT"`
+		Inputs      []*awsTxInput  `parquet:"name=inputs, type=LIST, repetitiontype=OPTIONAL, valuetype=STRUCT"`
+		Version     int64          `parquet:"name=version, type=INT64, repetitiontype=OPTIONAL"`
+		Size        int64          `parquet:"name=size, type=INT64, repetitiontype=OPTIONAL"`
+		BlockNumber int64          `parquet:"name=block_number, type=INT64, repetitiontype=OPTIONAL"`
+		Index       int64          `parquet:"name=index, type=INT64, repetitiontype=OPTIONAL"`
+		LockTime    int64          `parquet:"name=lock_time, type=INT64, repetitiontype=OPTIONAL"`
+		IsCoinbase  bool           `parquet:"name=is_coinbase, type=BOOLEAN, repetitiontype=OPTIONAL"`
+		// VirtualSize int64  `parquet:"name=virtual_size, type=INT64, repetitiontype=OPTIONAL"`
+		// InputCount  int64  `parquet:"name=input_count, type=INT64, repetitiontype=OPTIONAL"`
+		// OutputCount int64  `parquet:"name=output_count, type=INT64, repetitiontype=OPTIONAL"`
+		// OutputValue    float64        `parquet:"name=output_value, type=DOUBLE, repetitiontype=OPTIONAL"`
+		// BlockTimestamp string         `parquet:"name=block_timestamp, type=INT96, repetitiontype=OPTIONAL"`
+		// Date           string         `parquet:"name=date, type=BYTE_ARRAY, convertedtype=UTF8, repetitiontype=OPTIONAL"`
+		// LastModified   string         `parquet:"name=last_modified, type=INT96, repetitiontype=OPTIONAL"`
+		// Fee            float64        `parquet:"name=fee, type=DOUBLE, repetitiontype=OPTIONAL"`
+		// InputValue     float64        `parquet:"name=input_value, type=DOUBLE, repetitiontype=OPTIONAL"`
+	}
+	awsTxInput struct {
+		ScriptHex            string    `parquet:"name=script_hex, type=BYTE_ARRAY, convertedtype=UTF8, repetitiontype=OPTIONAL"`
+		SpentTransactionHash string    `parquet:"name=spent_transaction_hash, type=BYTE_ARRAY, convertedtype=UTF8, repetitiontype=OPTIONAL"`
+		TxInWitness          []*string `parquet:"name=txinwitness, type=LIST, repetitiontype=OPTIONAL, valuetype=BYTE_ARRAY, convertedtype=UTF8"`
+		SpentOutputIndex     int64     `parquet:"name=spent_output_index, type=INT64, repetitiontype=OPTIONAL"`
+		Sequence             int64     `parquet:"name=sequence, type=INT64, repetitiontype=OPTIONAL"`
+		// Address              string    `parquet:"name=address, type=BYTE_ARRAY, convertedtype=UTF8, repetitiontype=OPTIONAL"`
+		// Index                int64     `parquet:"name=index, type=INT64, repetitiontype=OPTIONAL"`
+		// RequiredSignatures   int64     `parquet:"name=required_signatures, type=INT64, repetitiontype=OPTIONAL"`
+		// ScriptAsm            string    `parquet:"name=script_asm, type=BYTE_ARRAY, convertedtype=UTF8, repetitiontype=OPTIONAL"`
+		// Type                 string    `parquet:"name=type, type=BYTE_ARRAY, convertedtype=UTF8, repetitiontype=OPTIONAL"`
+		// Value                float64   `parquet:"name=value, type=DOUBLE, repetitiontype=OPTIONAL"`
+	}
+	awsTxOutput struct {
+		Script_hex string  `parquet:"name=script_hex, type=BYTE_ARRAY, convertedtype=UTF8, repetitiontype=OPTIONAL"`
+		Value      float64 `parquet:"name=value, type=DOUBLE, repetitiontype=OPTIONAL"`
+		// Address             string  `parquet:"name=address, type=BYTE_ARRAY, convertedtype=UTF8, repetitiontype=OPTIONAL"`
+		// Index               int64   `parquet:"name=index, type=INT64, repetitiontype=OPTIONAL"`
+		// Required_signatures int64   `parquet:"name=required_signatures, type=INT64, repetitiontype=OPTIONAL"`
+		// Script_asm          string  `parquet:"name=script_asm, type=BYTE_ARRAY, convertedtype=UTF8, repetitiontype=OPTIONAL"`
+		// Type                string  `parquet:"name=type, type=BYTE_ARRAY, convertedtype=UTF8, repetitiontype=OPTIONAL"`
+	}
+
+	awsFile struct {
+		Key          string
+		Size         int64
+		LastModified time.Time
+	}
+)
+
+func (a awsBlock) ToBlockHeader() (types.BlockHeader, error) {
+	hash, err := chainhash.NewHashFromStr(a.Hash)
+	if err != nil {
+		return types.BlockHeader{}, errors.Wrap(err, "can't convert block hash")
+	}
+	prevBlockHash, err := chainhash.NewHashFromStr(a.PreviousBlockHash)
+	if err != nil {
+		return types.BlockHeader{}, errors.Wrap(err, "can't convert previous block hash")
+	}
+	merkleRoot, err := chainhash.NewHashFromStr(a.MerkleRoot)
+	if err != nil {
+		return types.BlockHeader{}, errors.Wrap(err, "can't convert merkle root")
+	}
+
+	bits, err := strconv.ParseUint(a.Bits, 16, 32)
+	if err != nil {
+		return types.BlockHeader{}, errors.Wrap(err, "can't convert bits from hex str to uint32")
+	}
+
+	return types.BlockHeader{
+		Hash:       *hash,
+		Height:     a.Number,
+		Version:    int32(a.Version),
+		PrevBlock:  *prevBlockHash,
+		MerkleRoot: *merkleRoot,
+		Timestamp:  parquettypes.INT96ToTime(a.Timestamp),
+		Bits:       uint32(bits),
+		Nonce:      uint32(a.Nonce),
+	}, nil
+}
+
+func (a awsTransaction) ToTransaction(block awsBlock) (*types.Transaction, error) {
+	blockhash, err := chainhash.NewHashFromStr(block.Hash)
+	if err != nil {
+		return nil, errors.Wrap(err, "can't convert block hash")
+	}
+	msgtx, err := a.MsgTx(block)
+	if err != nil {
+		return nil, errors.Wrap(err, "can't convert aws tx to wire.msgtx")
+	}
+	return types.ParseMsgTx(msgtx, a.BlockNumber, *blockhash, uint32(a.Index)), nil
+}
+
+func (a awsTransaction) MsgTx(block awsBlock) (*wire.MsgTx, error) {
+	txIn := make([]*wire.TxIn, 0, len(a.Inputs))
+	txOut := make([]*wire.TxOut, 0, len(a.Outputs))
+
+	// NOTE: coinbase tx from AWS S3 has no inputs, so we need to add it manually,
+	// but we can't guarantee this data is correct especially the sequence number.
+	if a.IsCoinbase && len(a.Inputs) == 0 {
+		scriptsig, err := hex.DecodeString(block.CoinbaseParam)
+		if err != nil {
+			return nil, errors.Wrap(err, "can't decode script hex")
+		}
+
+		txIn = append(txIn, &wire.TxIn{
+			PreviousOutPoint: wire.OutPoint{
+				Hash:  common.ZeroHash,
+				Index: math.MaxUint32,
+			},
+			SignatureScript: scriptsig,
+			Witness:         btcutils.CoinbaseWitness,
+			Sequence:        math.MaxUint32, // most coinbase tx are using max sequence number
+		})
+	}
+
+	for _, in := range a.Inputs {
+		scriptsig, err := hex.DecodeString(in.ScriptHex)
+		if err != nil {
+			return nil, errors.Wrap(err, "can't decode script hex")
+		}
+
+		witness, err := btcutils.WitnessFromHex(lo.Map(in.TxInWitness, func(src *string, _ int) string {
+			if src == nil {
+				return ""
+			}
+			return *src
+		}))
+		if err != nil {
+			return nil, errors.Wrap(err, "can't convert witness")
+		}
+
+		prevOutHash, err := chainhash.NewHashFromStr(in.SpentTransactionHash)
+		if err != nil {
+			return nil, errors.Wrap(err, "can't convert prevout hash")
+		}
+
+		txIn = append(txIn, &wire.TxIn{
+			PreviousOutPoint: wire.OutPoint{
+				Hash:  *prevOutHash,
+				Index: uint32(in.SpentOutputIndex),
+			},
+			SignatureScript: scriptsig,
+			Witness:         witness,
+			Sequence:        uint32(in.Sequence),
+		})
+	}
+
+	for _, out := range a.Outputs {
+		scriptpubkey, err := hex.DecodeString(out.Script_hex)
+		if err != nil {
+			return nil, errors.Wrap(err, "can't decode script hex")
+		}
+		txOut = append(txOut, &wire.TxOut{
+			Value:    btcutils.BitcoinToSatoshi(out.Value),
+			PkScript: scriptpubkey,
+		})
+	}
+
+	return &wire.MsgTx{
+		Version:  int32(a.Version),
+		TxIn:     txIn,
+		TxOut:    txOut,
+		LockTime: uint32(a.LockTime),
+	}, nil
+}

core/datasources/bitcoin_node.go

@@ -88,7 +88,7 @@ func (d *BitcoinNodeDatasource) FetchAsync(ctx context.Context, from, to int64,
 		slogx.String("datasource", d.Name()),
 	)
 
-	from, to, skip, err := d.prepareRange(from, to)
+	from, to, skip, err := d.prepareRange(ctx, from, to)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to prepare fetch range")
 	}
@@ -212,12 +212,12 @@ func (d *BitcoinNodeDatasource) FetchAsync(ctx context.Context, from, to int64,
 	return subscription.Client(), nil
 }
 
-func (d *BitcoinNodeDatasource) prepareRange(fromHeight, toHeight int64) (start, end int64, skip bool, err error) {
+func (d *BitcoinNodeDatasource) prepareRange(ctx context.Context, fromHeight, toHeight int64) (start, end int64, skip bool, err error) {
 	start = fromHeight
 	end = toHeight
 
 	// get current bitcoin block height
-	latestBlockHeight, err := d.btcclient.GetBlockCount()
+	latestBlockHeight, err := d.GetCurrentBlockHeight(ctx)
 	if err != nil {
 		return -1, -1, false, errors.Wrap(err, "failed to get block count")
 	}
@@ -227,7 +227,7 @@ func (d *BitcoinNodeDatasource) prepareRange(fromHeight, toHeight int64) (start,
 		start = 0
 	}
 
-	// set end to current bitcoin block height if
+	// set end to current bitcoin block height if     d
 	// - end is -1
 	// - end is greater that current bitcoin block height
 	if end < 0 || end > latestBlockHeight {
@@ -243,32 +243,39 @@ func (d *BitcoinNodeDatasource) prepareRange(fromHeight, toHeight int64) (start,
 }
 
 // GetTransaction fetch transaction from Bitcoin node
-func (d *BitcoinNodeDatasource) GetRawTransactionAndHeightByTxHash(ctx context.Context, txHash chainhash.Hash) (*wire.MsgTx, int64, error) {
+func (d *BitcoinNodeDatasource) GetTransactionByHash(ctx context.Context, txHash chainhash.Hash) (*types.Transaction, error) {
 	rawTxVerbose, err := d.btcclient.GetRawTransactionVerbose(&txHash)
 	if err != nil {
-		return nil, 0, errors.Wrap(err, "failed to get raw transaction")
+		return nil, errors.Wrap(err, "failed to get raw transaction")
 	}
 
 	blockHash, err := chainhash.NewHashFromStr(rawTxVerbose.BlockHash)
 	if err != nil {
-		return nil, 0, errors.Wrap(err, "failed to parse block hash")
+		return nil, errors.Wrap(err, "failed to parse block hash")
 	}
-	block, err := d.btcclient.GetBlockVerbose(blockHash)
+	block, err := d.btcclient.GetBlockVerboseTx(blockHash)
 	if err != nil {
-		return nil, 0, errors.Wrap(err, "failed to get block header")
+		return nil, errors.Wrap(err, "failed to get block header")
 	}
 
 	// parse tx
 	txBytes, err := hex.DecodeString(rawTxVerbose.Hex)
 	if err != nil {
-		return nil, 0, errors.Wrap(err, "failed to decode transaction hex")
+		return nil, errors.Wrap(err, "failed to decode transaction hex")
 	}
 	var msgTx wire.MsgTx
 	if err := msgTx.Deserialize(bytes.NewReader(txBytes)); err != nil {
-		return nil, 0, errors.Wrap(err, "failed to deserialize transaction")
+		return nil, errors.Wrap(err, "failed to deserialize transaction")
+	}
+	var txIndex uint32
+	for i, tx := range block.Tx {
+		if tx.Hex == rawTxVerbose.Hex {
+			txIndex = uint32(i)
+			break
+		}
 	}
 
-	return &msgTx, block.Height, nil
+	return types.ParseMsgTx(&msgTx, block.Height, *blockHash, txIndex), nil
 }
 
 // GetBlockHeader fetch block header from Bitcoin node
@@ -286,11 +293,11 @@ func (d *BitcoinNodeDatasource) GetBlockHeader(ctx context.Context, height int64
 	return types.ParseMsgBlockHeader(*block, height), nil
 }
 
-func (d *BitcoinNodeDatasource) GetRawTransactionByTxHash(ctx context.Context, txHash chainhash.Hash) (*wire.MsgTx, error) {
-	transaction, err := d.btcclient.GetRawTransaction(&txHash)
+// GetCurrentBlockHeight fetch current block height from Bitcoin node
+func (d *BitcoinNodeDatasource) GetCurrentBlockHeight(ctx context.Context) (int64, error) {
+	height, err := d.btcclient.GetBlockCount()
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to get raw transaction")
+		return -1, errors.Wrap(err, "failed to get block height")
 	}
-
-	return transaction.MsgTx(), nil
+	return height, nil
 }

core/datasources/datasources.go

@@ -13,4 +13,5 @@ type Datasource[T any] interface {
 	Fetch(ctx context.Context, from, to int64) ([]T, error)
 	FetchAsync(ctx context.Context, from, to int64, ch chan<- []T) (*subscription.ClientSubscription[[]T], error)
 	GetBlockHeader(ctx context.Context, height int64) (types.BlockHeader, error)
+	GetCurrentBlockHeight(ctx context.Context) (int64, error)
 }

core/indexer/indexer.go

@@ -6,7 +6,6 @@ import (
 	"sync"
 	"time"
 
-	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/cockroachdb/errors"
 	"github.com/gaze-network/indexer-network/common/errs"
 	"github.com/gaze-network/indexer-network/core/datasources"
@@ -92,10 +91,6 @@ func (i *Indexer[T]) Run(ctx context.Context) (err error) {
 		select {
 		case <-i.quit:
 			logger.InfoContext(ctx, "Got quit signal, stopping indexer")
-			if err := i.Processor.Shutdown(ctx); err != nil {
-				logger.ErrorContext(ctx, "Failed to shutdown processor", slogx.Error(err))
-				return errors.Wrap(err, "processor shutdown failed")
-			}
 			return nil
 		case <-ctx.Done():
 			return nil
@@ -143,7 +138,7 @@ func (i *Indexer[T]) process(ctx context.Context) (err error) {
 			// validate reorg from first input
 			{
 				remoteBlockHeader := firstInputHeader
-				if i.currentBlock.Hash != (chainhash.Hash{}) && !remoteBlockHeader.PrevBlock.IsEqual(&i.currentBlock.Hash) {
+				if !remoteBlockHeader.PrevBlock.IsEqual(&i.currentBlock.Hash) {
 					logger.WarnContext(ctx, "Detected chain reorganization. Searching for fork point...",
 						slogx.String("event", "reorg_detected"),
 						slogx.Stringer("current_hash", i.currentBlock.Hash),
@@ -209,20 +204,19 @@ func (i *Indexer[T]) process(ctx context.Context) (err error) {
 			}
 
 			// validate is input is continuous and no reorg
-			prevHeader := i.currentBlock
-			for i, input := range inputs {
-				header := input.BlockHeader()
+			for i := 1; i < len(inputs); i++ {
+				header := inputs[i].BlockHeader()
+				prevHeader := inputs[i-1].BlockHeader()
 				if header.Height != prevHeader.Height+1 {
 					return errors.Wrapf(errs.InternalError, "input is not continuous, input[%d] height: %d, input[%d] height: %d", i-1, prevHeader.Height, i, header.Height)
 				}
 
-				if prevHeader.Hash != (chainhash.Hash{}) && !header.PrevBlock.IsEqual(&prevHeader.Hash) {
+				if !header.PrevBlock.IsEqual(&prevHeader.Hash) {
 					logger.WarnContext(ctx, "Chain Reorganization occurred in the middle of batch fetching inputs, need to try to fetch again")
 
 					// end current round
 					return nil
 				}
-				prevHeader = header
 			}
 
 			ctx = logger.WithContext(ctx, slog.Int("total_inputs", len(inputs)))

core/indexer/interface.go

@@ -29,9 +29,6 @@ type Processor[T Input] interface {
 	// VerifyStates verifies the states of the indexed data and the indexer
 	// to ensure the last shutdown was graceful and no missing data.
 	VerifyStates(ctx context.Context) error
-
-	// Shutdown gracefully stops the processor. Database connections, network calls, leftover states, etc. should be closed and cleaned up here.
-	Shutdown(ctx context.Context) error
 }
 
 type IndexerWorker interface {

docs/README_tr.md

@@ -1,165 +0,0 @@
-## Çeviriler
-- [English (İngilizce)](../README.md)
-
-**Son Güncelleme:** 21 Ağustos 2024
-> **Not:** Bu belge, topluluk tarafından yapılmış bir çeviridir. Ana README.md dosyasındaki güncellemeler buraya otomatik olarak yansıtılmayabilir. En güncel bilgiler için [İngilizce sürümü](../README.md) inceleyin.
-
-
-# Gaze Indexer
-
-Gaze Indexer, değiştirilebilir token protokolleri arasında **Birleştirilmiş Tutarlı API'lere** sahip Bitcoin meta-protokolleri için açık kaynaklı ve modüler bir indeksleme istemcisidir.
-
-Gaze Indexer, kullanıcıların tüm modülleri tek bir komutla tek bir monolitik örnekte veya dağıtılmış bir mikro hizmet kümesi olarak çalıştırmasına olanak tanıyan **modülerlik** göz önünde bulundurularak oluşturulmuştur.
-
-Gaze Indexer, verimli veri getirme, yeniden düzenleme algılama ve veritabanı taşıma aracı ile HERHANGİ bir meta-protokol indeksleyici oluşturmak için bir temel görevi görür.
-Bu, geliştiricilerin **gerçekten** önemli olana odaklanmasını sağlar: Meta-protokol indeksleme mantığı. Yeni meta-protokoller, yeni modüller uygulanarak kolayca eklenebilir.
-
-- [Modüller](#modules)
-  - [1. Runes](#1-runes)
-- [Kurulum](#installation)
-  - [Önkoşullar](#prerequisites)
-    - [1. Donanım Gereksinimleri](#1-hardware-requirements)
-    - [2. Bitcoin Core RPC sunucusunu hazırlayın.](#2-prepare-bitcoin-core-rpc-server)
-    - [3. Veritabanı hazırlayın.](#3-prepare-database)
-    - [4.  `config.yaml` dosyasını hazırlayın.](#4-prepare-configyaml-file)
-  - [Docker ile yükle (önerilir)](#install-with-docker-recommended)
-  - [Kaynaktan yükle](#install-from-source)
-
-## Modüller
-
-### 1. Runes
-
-Runes Dizinleyici ilk meta-protokol dizinleyicimizdir. Bitcoin işlemlerini kullanarak Runes durumlarını, işlemlerini, rün taşlarını ve bakiyelerini indeksler.
-Geçmiş Runes verilerini sorgulamak için bir dizi API ile birlikte gelir. Tüm ayrıntılar için [API Referansı] (https://api-docs.gaze.network) adresimize bakın.
-
-
-## Kurulum
-
-### Önkoşullar
-
-#### 1. Donanım Gereksinimleri
-
-Her modül farklı donanım gereksinimleri gerektirir.
-| Modül | CPU | RAM |
-| ------ | --------- | ---- |
-| Runes | 0,5 çekirdek | 1 GB |
-
-#### 2. Bitcoin Core RPC sunucusunu hazırlayın.
-
-Gaze Indexer'ın işlem verilerini kendi barındırdığı ya da QuickNode gibi yönetilen sağlayıcıları kullanan bir Bitcoin Core RPC'den alması gerekir.
-Bir Bitcoin Core'u kendiniz barındırmak için bkz. https://bitcoin.org/en/full-node.
-
-#### 3. Veritabanını hazırlayın.
-
-Gaze Indexer PostgreSQL için birinci sınıf desteğe sahiptir. Diğer veritabanlarını kullanmak isterseniz, her modülün Veri Ağ Geçidi arayüzünü karşılayan kendi veritabanı havuzunuzu uygulayabilirsiniz.
-İşte her modül için minimum veritabanı disk alanı gereksinimimiz.
-| Modül | Veritabanı Depolama Alanı (mevcut) | Veritabanı Depolama Alanı (1 yıl içinde) |
-| ------ | -------------------------- | ---------------------------- |
-| Runes | 10 GB | 150 GB |
-
-#### 4. config.yaml` dosyasını hazırlayın.
-
-```yaml
-# config.yaml
-logger:
-  output: TEXT # Output format for logs. current supported formats: "TEXT" | "JSON" | "GCP"
-  debug: false
-
-# Network to run the indexer on. Current supported networks: "mainnet" | "testnet"
-network: mainnet
-
-# Bitcoin Core RPC configuration options.
-bitcoin_node:
-  host: "" # [Required] Host of Bitcoin Core RPC (without https://)
-  user: "" # Username to authenticate with Bitcoin Core RPC
-  pass: "" # Password to authenticate with Bitcoin Core RPC
-  disable_tls: false # Set to true to disable tls
-
-# Block reporting configuration options. See Block Reporting section for more details.
-reporting:
-  disabled: false # Set to true to disable block reporting to Gaze Network. Default is false.
-  base_url: "https://indexer.api.gaze.network" # Defaults to "https://indexer.api.gaze.network" if left empty
-  name: "" # [Required if not disabled] Name of this indexer to show on the Gaze Network dashboard
-  website_url: "" # Public website URL to show on the dashboard. Can be left empty.
-  indexer_api_url: "" # Public url to access this indexer's API. Can be left empty if you want to keep your indexer private.
-
-# HTTP server configuration options.
-http_server:
-  port: 8080 # Port to run the HTTP server on for modules with HTTP API handlers.
-
-# Meta-protocol modules configuration options.
-modules:
-  # Configuration options for Runes module. Can be removed if not used.
-  runes:
-    database: "postgres" # Database to store Runes data. current supported databases: "postgres"
-    datasource: "bitcoin-node" # Data source to be used for Bitcoin data. current supported data sources: "bitcoin-node".
-    api_handlers: # API handlers to enable. current supported handlers: "http"
-      - http
-    postgres:
-      host: "localhost"
-      port: 5432
-      user: "postgres"
-      password: "password"
-      db_name: "postgres"
-      # url: "postgres://postgres:password@localhost:5432/postgres?sslmode=prefer" # [Optional] This will override other database credentials above.
-```
-
-### Docker ile yükleyin (önerilir)
-
-Kurulum kılavuzumuz için `docker-compose` kullanacağız. Docker-compose.yaml` dosyasının `config.yaml` dosyası ile aynı dizinde olduğundan emin olun.
-
-```yaml
-# docker-compose.yaml
-services:
-  gaze-indexer:
-    image: ghcr.io/gaze-network/gaze-indexer:v0.2.1
-    container_name: gaze-indexer
-    restart: unless-stopped
-    ports:
-      - 8080:8080 # Expose HTTP server port to host
-    volumes:
-      - "./config.yaml:/app/config.yaml" # mount config.yaml file to the container as "/app/config.yaml"
-    command: ["/app/main", "run", "--modules", "runes"] # Put module flags after "run" commands to select which modules to run.
-```
-
-### Kaynaktan yükleyin
-
-1. Go` sürüm 1.22 veya daha üstünü yükleyin. Go kurulum kılavuzuna bakın [burada](https://go.dev/doc/install).
-2. Bu depoyu klonlayın.
-
-```bash
-git clone https://github.com/gaze-network/gaze-indexer.git
-cd gaze-indexer
-```
-
-3. Ana ikili dosyayı oluşturun.
-
-```bash
-# Bağımlılıkları al
-go mod indir
-
-# Ana ikili dosyayı oluşturun
-go build -o gaze main.go
-```
-
-4. Veritabanı geçişlerini `migrate` komutu ve modül bayrakları ile çalıştırın.
-
-```bash
-./gaze migrate up --runes --database postgres://postgres:password@localhost:5432/postgres
-```
-
-5. Dizinleyiciyi `run` komutu ve modül bayrakları ile başlatın.
-
-```bash
-./gaze run --modules runes
-```
-
-Eğer `config.yaml` dosyası `./app/config.yaml` adresinde bulunmuyorsa, `config.yaml` dosyasının yolunu belirtmek için `--config` bayrağını kullanın.
-
-```bash
-./gaze run --modules runes --config /path/to/config.yaml
-```
-
-
-## Çeviriler
-- [English (İngilizce)](../README.md)

go.mod

@@ -4,9 +4,12 @@ go 1.22
 
 require (
 	github.com/Cleverse/go-utilities/utils v0.0.0-20240119201306-d71eb577ef11
+	github.com/aws/aws-sdk-go-v2 v1.23.0
+	github.com/aws/aws-sdk-go-v2/config v1.25.3
+	github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.14.0
+	github.com/aws/aws-sdk-go-v2/service/s3 v1.43.0
 	github.com/btcsuite/btcd v0.24.0
 	github.com/btcsuite/btcd/btcutil v1.1.5
-	github.com/btcsuite/btcd/btcutil/psbt v1.1.9
 	github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0
 	github.com/cockroachdb/errors v1.11.1
 	github.com/gaze-network/uint128 v1.3.0
@@ -17,34 +20,50 @@ require (
 	github.com/planxnx/concurrent-stream v0.1.5
 	github.com/samber/do/v2 v2.0.0-beta.7
 	github.com/samber/lo v1.39.0
-	github.com/shopspring/decimal v1.3.1
+	github.com/shopspring/decimal v1.4.0
 	github.com/spf13/cobra v1.8.0
 	github.com/spf13/pflag v1.0.5
 	github.com/spf13/viper v1.18.2
-	github.com/stretchr/testify v1.9.0
+	github.com/stretchr/testify v1.8.4
 	github.com/valyala/fasthttp v1.51.0
+	github.com/xitongsys/parquet-go v1.6.2
+	github.com/xitongsys/parquet-go-source v0.0.0-20240122235623-d6294584ab18
 	go.uber.org/automaxprocs v1.5.3
-	golang.org/x/sync v0.7.0
-	google.golang.org/protobuf v1.33.0
+	golang.org/x/sync v0.5.0
 )
 
-require github.com/stretchr/objx v0.5.2 // indirect
-
 require (
 	github.com/andybalholm/brotli v1.0.5 // indirect
-	github.com/bitonicnl/verify-signed-message v0.7.1
-	github.com/btcsuite/btcd/btcec/v2 v2.3.3
+	github.com/apache/arrow/go/arrow v0.0.0-20200730104253-651201b0f516 // indirect
+	github.com/apache/thrift v0.20.0 // indirect
+	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.5.1 // indirect
+	github.com/aws/aws-sdk-go-v2/credentials v1.16.2 // indirect
+	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.14.4 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/configsources v1.2.3 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.5.3 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/ini v1.7.1 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/v4a v1.2.3 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.10.1 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.2.3 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.10.3 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.16.3 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sso v1.17.2 // indirect
+	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.20.0 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sts v1.25.3 // indirect
+	github.com/aws/smithy-go v1.17.0 // indirect
+	github.com/btcsuite/btcd/btcec/v2 v2.1.3 // indirect
 	github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f // indirect
 	github.com/btcsuite/go-socks v0.0.0-20170105172521-4720035b7bfd // indirect
 	github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792 // indirect
 	github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b // indirect
 	github.com/cockroachdb/redact v1.1.5 // indirect
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
-	github.com/decred/dcrd/crypto/blake256 v1.0.1 // indirect
-	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0
+	github.com/decred/dcrd/crypto/blake256 v1.0.0 // indirect
+	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 // indirect
 	github.com/fsnotify/fsnotify v1.7.0 // indirect
 	github.com/getsentry/sentry-go v0.18.0 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/golang/snappy v0.0.4 // indirect
 	github.com/google/uuid v1.5.0 // indirect
 	github.com/hashicorp/errwrap v1.1.0 // indirect
 	github.com/hashicorp/go-multierror v1.1.1 // indirect
@@ -54,6 +73,7 @@ require (
 	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
 	github.com/jackc/pgx v3.6.2+incompatible // indirect
 	github.com/jackc/puddle/v2 v2.2.1 // indirect
+	github.com/jmespath/go-jmespath v0.4.0 // indirect
 	github.com/klauspost/compress v1.17.0 // indirect
 	github.com/kr/pretty v0.3.1 // indirect
 	github.com/kr/text v0.2.0 // indirect
@@ -64,6 +84,7 @@ require (
 	github.com/mattn/go-runewidth v0.0.15 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
 	github.com/pelletier/go-toml/v2 v2.1.0 // indirect
+	github.com/pierrec/lz4/v4 v4.1.16 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
 	github.com/rivo/uniseg v0.2.0 // indirect
@@ -79,10 +100,11 @@ require (
 	github.com/valyala/tcplisten v1.0.0 // indirect
 	go.uber.org/atomic v1.9.0 // indirect
 	go.uber.org/multierr v1.9.0 // indirect
-	golang.org/x/crypto v0.23.0 // indirect
-	golang.org/x/exp v0.0.0-20240525044651-4c93da0ed11d // indirect
-	golang.org/x/sys v0.20.0 // indirect
-	golang.org/x/text v0.15.0 // indirect
+	golang.org/x/crypto v0.20.0 // indirect
+	golang.org/x/exp v0.0.0-20230905200255-921286631fa9 // indirect
+	golang.org/x/sys v0.17.0 // indirect
+	golang.org/x/text v0.14.0 // indirect
+	golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 // indirect
 	gopkg.in/ini.v1 v1.67.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

internal/config/config.go

@@ -8,12 +8,9 @@ import (
 
 	"github.com/cockroachdb/errors"
 	"github.com/gaze-network/indexer-network/common"
-	nodesaleconfig "github.com/gaze-network/indexer-network/modules/nodesale/config"
 	runesconfig "github.com/gaze-network/indexer-network/modules/runes/config"
 	"github.com/gaze-network/indexer-network/pkg/logger"
 	"github.com/gaze-network/indexer-network/pkg/logger/slogx"
-	"github.com/gaze-network/indexer-network/pkg/middleware/requestcontext"
-	"github.com/gaze-network/indexer-network/pkg/middleware/requestlogger"
 	"github.com/gaze-network/indexer-network/pkg/reportingclient"
 	"github.com/spf13/pflag"
 	"github.com/spf13/viper"
@@ -62,14 +59,11 @@ type BitcoinNodeClient struct {
 }
 
 type Modules struct {
-	Runes    runesconfig.Config    `mapstructure:"runes"`
-	NodeSale nodesaleconfig.Config `mapstructure:"nodesale"`
+	Runes runesconfig.Config `mapstructure:"runes"`
 }
 
 type HTTPServerConfig struct {
-	Port      int                               `mapstructure:"port"`
-	Logger    requestlogger.Config              `mapstructure:"logger"`
-	RequestIP requestcontext.WithClientIPConfig `mapstructure:"requestip"`
+	Port int `mapstructure:"port"`
 }
 
 // Parse parse the configuration from environment variables

modules/nodesale/api/httphandler/deploy.go

@@ -1,99 +0,0 @@
-package httphandler
-
-import (
-	"fmt"
-
-	"github.com/cockroachdb/errors"
-	"github.com/gaze-network/indexer-network/common/errs"
-	"github.com/gaze-network/indexer-network/modules/nodesale/datagateway"
-	"github.com/gaze-network/indexer-network/modules/nodesale/protobuf"
-	"github.com/gofiber/fiber/v2"
-	"google.golang.org/protobuf/encoding/protojson"
-)
-
-type deployRequest struct {
-	DeployID string `params:"deployId"`
-}
-
-type tierResponse struct {
-	PriceSat      uint32 `json:"priceSat"`
-	Limit         uint32 `json:"limit"`
-	MaxPerAddress uint32 `json:"maxPerAddress"`
-	Sold          int64  `json:"sold"`
-}
-
-type deployResponse struct {
-	Id              string         `json:"id"`
-	Name            string         `json:"name"`
-	StartsAt        int64          `json:"startsAt"`
-	EndsAt          int64          `json:"endsAt"`
-	Tiers           []tierResponse `json:"tiers"`
-	SellerPublicKey string         `json:"sellerPublicKey"`
-	MaxPerAddress   uint32         `json:"maxPerAddress"`
-	DeployTxHash    string         `json:"deployTxHash"`
-}
-
-func (h *handler) deployHandler(ctx *fiber.Ctx) error {
-	var request deployRequest
-	err := ctx.ParamsParser(&request)
-	if err != nil {
-		return errors.Wrap(err, "cannot parse param")
-	}
-	var blockHeight uint64
-	var txIndex uint32
-	count, err := fmt.Sscanf(request.DeployID, "%d-%d", &blockHeight, &txIndex)
-	if count != 2 || err != nil {
-		return errs.NewPublicError("Invalid deploy ID")
-	}
-	deploys, err := h.nodeSaleDg.GetNodeSale(ctx.UserContext(), datagateway.GetNodeSaleParams{
-		BlockHeight: blockHeight,
-		TxIndex:     txIndex,
-	})
-	if err != nil {
-		return errors.Wrap(err, "Cannot get NodeSale from db")
-	}
-	if len(deploys) < 1 {
-		return errs.NewPublicError("NodeSale not found")
-	}
-
-	deploy := deploys[0]
-
-	nodeCount, err := h.nodeSaleDg.GetNodeCountByTierIndex(ctx.UserContext(), datagateway.GetNodeCountByTierIndexParams{
-		SaleBlock:   deploy.BlockHeight,
-		SaleTxIndex: deploy.TxIndex,
-		FromTier:    0,
-		ToTier:      uint32(len(deploy.Tiers) - 1),
-	})
-	if err != nil {
-		return errors.Wrap(err, "Cannot get node count from db")
-	}
-
-	tiers := make([]protobuf.Tier, len(deploy.Tiers))
-	tierResponses := make([]tierResponse, len(deploy.Tiers))
-	for i, tierJson := range deploy.Tiers {
-		tier := &tiers[i]
-		err := protojson.Unmarshal(tierJson, tier)
-		if err != nil {
-			return errors.Wrap(err, "Failed to decode tiers json")
-		}
-		tierResponses[i].Limit = tiers[i].Limit
-		tierResponses[i].MaxPerAddress = tiers[i].MaxPerAddress
-		tierResponses[i].PriceSat = tiers[i].PriceSat
-		tierResponses[i].Sold = nodeCount[i].Count
-	}
-
-	err = ctx.JSON(&deployResponse{
-		Id:              request.DeployID,
-		Name:            deploy.Name,
-		StartsAt:        deploy.StartsAt.UTC().Unix(),
-		EndsAt:          deploy.EndsAt.UTC().Unix(),
-		Tiers:           tierResponses,
-		SellerPublicKey: deploy.SellerPublicKey,
-		MaxPerAddress:   deploy.MaxPerAddress,
-		DeployTxHash:    deploy.DeployTxHash,
-	})
-	if err != nil {
-		return errors.Wrap(err, "Go fiber cannot parse JSON")
-	}
-	return nil
-}

modules/nodesale/api/httphandler/events.go

@@ -1,56 +0,0 @@
-package httphandler
-
-import (
-	"encoding/json"
-	"time"
-
-	"github.com/cockroachdb/errors"
-	"github.com/gaze-network/indexer-network/modules/nodesale/protobuf"
-	"github.com/gofiber/fiber/v2"
-)
-
-type eventRequest struct {
-	WalletAddress string `query:"walletAddress"`
-}
-
-type eventResposne struct {
-	TxHash         string          `json:"txHash"`
-	BlockHeight    int64           `json:"blockHeight"`
-	TxIndex        int32           `json:"txIndex"`
-	WalletAddress  string          `json:"walletAddress"`
-	Action         string          `json:"action"`
-	ParsedMessage  json.RawMessage `json:"parsedMessage"`
-	BlockTimestamp time.Time       `json:"blockTimestamp"`
-	BlockHash      string          `json:"blockHash"`
-}
-
-func (h *handler) eventsHandler(ctx *fiber.Ctx) error {
-	var request eventRequest
-	err := ctx.QueryParser(&request)
-	if err != nil {
-		return errors.Wrap(err, "cannot parse query")
-	}
-
-	events, err := h.nodeSaleDg.GetEventsByWallet(ctx.UserContext(), request.WalletAddress)
-	if err != nil {
-		return errors.Wrap(err, "Can't get events from db")
-	}
-
-	responses := make([]eventResposne, len(events))
-	for i, event := range events {
-		responses[i].TxHash = event.TxHash
-		responses[i].BlockHeight = event.BlockHeight
-		responses[i].TxIndex = event.TxIndex
-		responses[i].WalletAddress = event.WalletAddress
-		responses[i].Action = protobuf.Action_name[event.Action]
-		responses[i].ParsedMessage = event.ParsedMessage
-		responses[i].BlockTimestamp = event.BlockTimestamp
-		responses[i].BlockHash = event.BlockHash
-	}
-
-	err = ctx.JSON(responses)
-	if err != nil {
-		return errors.Wrap(err, "Go fiber cannot parse JSON")
-	}
-	return nil
-}

modules/nodesale/api/httphandler/handler.go

@@ -1,15 +0,0 @@
-package httphandler
-
-import (
-	"github.com/gaze-network/indexer-network/modules/nodesale/datagateway"
-)
-
-type handler struct {
-	nodeSaleDg datagateway.NodeSaleDataGateway
-}
-
-func New(datagateway datagateway.NodeSaleDataGateway) *handler {
-	h := handler{}
-	h.nodeSaleDg = datagateway
-	return &h
-}

modules/nodesale/api/httphandler/info.go

@@ -1,26 +0,0 @@
-package httphandler
-
-import (
-	"github.com/cockroachdb/errors"
-	"github.com/gofiber/fiber/v2"
-)
-
-type infoResponse struct {
-	IndexedBlockHeight int64  `json:"indexedBlockHeight"`
-	IndexedBlockHash   string `json:"indexedBlockHash"`
-}
-
-func (h *handler) infoHandler(ctx *fiber.Ctx) error {
-	block, err := h.nodeSaleDg.GetLastProcessedBlock(ctx.UserContext())
-	if err != nil {
-		return errors.Wrap(err, "Cannot get last processed block")
-	}
-	err = ctx.JSON(infoResponse{
-		IndexedBlockHeight: block.BlockHeight,
-		IndexedBlockHash:   block.BlockHash,
-	})
-	if err != nil {
-		return errors.Wrap(err, "Go fiber cannot parse JSON")
-	}
-	return nil
-}

modules/nodesale/api/httphandler/nodes.go

@@ -1,82 +0,0 @@
-package httphandler
-
-import (
-	"fmt"
-
-	"github.com/cockroachdb/errors"
-	"github.com/gaze-network/indexer-network/common/errs"
-	"github.com/gaze-network/indexer-network/modules/nodesale/datagateway"
-	"github.com/gaze-network/indexer-network/modules/nodesale/internal/entity"
-	"github.com/gofiber/fiber/v2"
-)
-
-type nodeRequest struct {
-	DeployId           string `query:"deployId"`
-	OwnerPublicKey     string `query:"ownerPublicKey"`
-	DelegateePublicKey string `query:"delegateePublicKey"`
-}
-
-type nodeResponse struct {
-	DeployId            string `json:"deployId"`
-	NodeId              uint32 `json:"nodeId"`
-	TierIndex           int32  `json:"tierIndex"`
-	DelegatedTo         string `json:"delegatedTo"`
-	OwnerPublicKey      string `json:"ownerPublicKey"`
-	PurchaseTxHash      string `json:"purchaseTxHash"`
-	DelegateTxHash      string `json:"delegateTxHash"`
-	PurchaseBlockHeight int32  `json:"purchaseBlockHeight"`
-}
-
-func (h *handler) nodesHandler(ctx *fiber.Ctx) error {
-	var request nodeRequest
-	err := ctx.QueryParser(&request)
-	if err != nil {
-		return errors.Wrap(err, "cannot parse query")
-	}
-
-	ownerPublicKey := request.OwnerPublicKey
-	delegateePublicKey := request.DelegateePublicKey
-
-	var blockHeight int64
-	var txIndex int32
-	count, err := fmt.Sscanf(request.DeployId, "%d-%d", &blockHeight, &txIndex)
-	if count != 2 || err != nil {
-		return errs.NewPublicError("Invalid deploy ID")
-	}
-
-	var nodes []entity.Node
-	if ownerPublicKey == "" {
-		nodes, err = h.nodeSaleDg.GetNodesByDeployment(ctx.UserContext(), blockHeight, txIndex)
-		if err != nil {
-			return errors.Wrap(err, "Can't get nodes from db")
-		}
-	} else {
-		nodes, err = h.nodeSaleDg.GetNodesByPubkey(ctx.UserContext(), datagateway.GetNodesByPubkeyParams{
-			SaleBlock:      blockHeight,
-			SaleTxIndex:    txIndex,
-			OwnerPublicKey: ownerPublicKey,
-			DelegatedTo:    delegateePublicKey,
-		})
-		if err != nil {
-			return errors.Wrap(err, "Can't get nodes from db")
-		}
-	}
-
-	responses := make([]nodeResponse, len(nodes))
-	for i, node := range nodes {
-		responses[i].DeployId = request.DeployId
-		responses[i].NodeId = node.NodeID
-		responses[i].TierIndex = node.TierIndex
-		responses[i].DelegatedTo = node.DelegatedTo
-		responses[i].OwnerPublicKey = node.OwnerPublicKey
-		responses[i].PurchaseTxHash = node.PurchaseTxHash
-		responses[i].DelegateTxHash = node.DelegateTxHash
-		responses[i].PurchaseBlockHeight = txIndex
-	}
-
-	err = ctx.JSON(responses)
-	if err != nil {
-		return errors.Wrap(err, "Go fiber cannot parse JSON")
-	}
-	return nil
-}

modules/nodesale/api/httphandler/routes.go

@@ -1,16 +0,0 @@
-package httphandler
-
-import (
-	"github.com/gofiber/fiber/v2"
-)
-
-func (h *handler) Mount(router fiber.Router) error {
-	r := router.Group("/nodesale/v1")
-
-	r.Get("/info", h.infoHandler)
-	r.Get("/deploy/:deployId", h.deployHandler)
-	r.Get("/nodes", h.nodesHandler)
-	r.Get("/events", h.eventsHandler)
-
-	return nil
-}

modules/nodesale/config/config.go

@@ -1,8 +0,0 @@
-package config
-
-import "github.com/gaze-network/indexer-network/internal/postgres"
-
-type Config struct {
-	Postgres         postgres.Config `mapstructure:"postgres"`
-	LastBlockDefault int64           `mapstructure:"last_block_default"`
-}

modules/nodesale/database/postgresql/migrations/000001_initialize.down.sql

@@ -1,9 +0,0 @@
-BEGIN;
-
-DROP TABLE IF EXISTS nodes;
-DROP TABLE IF EXISTS node_sales;
-DROP TABLE IF EXISTS events;
-DROP TABLE IF EXISTS blocks;
-
-
-COMMIT;

modules/nodesale/database/postgresql/migrations/000001_initialize.up.sql

@@ -1,64 +0,0 @@
-BEGIN;
-
-CREATE TABLE IF NOT EXISTS blocks (
-    "block_height" BIGINT NOT NULL,
-    "block_hash" TEXT NOT NULL,
-    "module" TEXT NOT NULL,
-    PRIMARY KEY("block_height", "block_hash")
-);
-
-CREATE TABLE IF NOT EXISTS events (
-    "tx_hash" TEXT NOT NULL PRIMARY KEY,
-    "block_height" BIGINT NOT NULL,
-    "tx_index" INTEGER NOT NULL,
-    "wallet_address" TEXT NOT NULL,
-    "valid" BOOLEAN NOT NULL,
-    "action" INTEGER NOT NULL,
-    "raw_message" BYTEA NOT NULL,
-    "parsed_message" JSONB NOT NULL DEFAULT '{}',
-    "block_timestamp" TIMESTAMP NOT NULL,
-    "block_hash" TEXT NOT NULL,
-    "metadata" JSONB NOT NULL DEFAULT '{}',
-    "reason" TEXT NOT NULL DEFAULT ''
-);
-
-INSERT INTO events("tx_hash", "block_height", "tx_index",
-                 "wallet_address", "valid", "action", 
-                "raw_message", "parsed_message", "block_timestamp",
-                "block_hash", "metadata")
-VALUES ('', -1, -1,
-        '', false, -1,
-        '', '{}', NOW(),
-        '', '{}');
-
-CREATE TABLE IF NOT EXISTS node_sales (
-    "block_height" BIGINT NOT NULL,
-    "tx_index" INTEGER NOT NULL,
-    "name" TEXT NOT NULL,
-    "starts_at" TIMESTAMP NOT NULL,
-    "ends_at" TIMESTAMP NOT NULL,
-    "tiers" JSONB[] NOT NULL,
-    "seller_public_key" TEXT NOT NULL,
-    "max_per_address" INTEGER NOT NULL,
-    "deploy_tx_hash" TEXT NOT NULL REFERENCES events(tx_hash) ON DELETE CASCADE,
-    "max_discount_percentage" INTEGER NOT NULL,
-    "seller_wallet" TEXT NOT NULL,
-    PRIMARY KEY ("block_height", "tx_index")
-);
-
-CREATE TABLE IF NOT EXISTS nodes (
-    "sale_block" BIGINT NOT NULL,
-    "sale_tx_index" INTEGER NOT NULL,
-    "node_id" INTEGER NOT NULL,
-    "tier_index" INTEGER NOT NULL,
-    "delegated_to" TEXT NOT NULL DEFAULT '',
-    "owner_public_key" TEXT NOT NULL,
-    "purchase_tx_hash" TEXT NOT NULL REFERENCES events(tx_hash) ON DELETE CASCADE,
-    "delegate_tx_hash" TEXT NOT NULL DEFAULT '' REFERENCES events(tx_hash) ON DELETE SET DEFAULT,
-    PRIMARY KEY("sale_block", "sale_tx_index", "node_id"),
-    FOREIGN KEY("sale_block", "sale_tx_index") REFERENCES node_sales("block_height", "tx_index")
-);
-
-
-
-COMMIT;

modules/nodesale/database/postgresql/queries/blocks.sql

@@ -1,15 +0,0 @@
--- name: GetLastProcessedBlock :one
-SELECT * FROM blocks ORDER BY block_height DESC LIMIT 1;  
-
-
--- name: GetBlock :one
-SELECT * FROM blocks
-WHERE "block_height" = $1;
-
--- name: RemoveBlockFrom :execrows
-DELETE FROM blocks
-WHERE "block_height" >= @from_block;
-
--- name: CreateBlock :exec
-INSERT INTO blocks ("block_height", "block_hash", "module")
-VALUES ($1, $2, $3);

modules/nodesale/database/postgresql/queries/events.sql

@@ -1,14 +0,0 @@
--- name: RemoveEventsFromBlock :execrows
-DELETE FROM events
-WHERE "block_height" >= @from_block;
-
--- name: CreateEvent :exec
-INSERT INTO events ("tx_hash", "block_height", "tx_index", "wallet_address", "valid", "action", 
-                    "raw_message", "parsed_message", "block_timestamp", "block_hash", "metadata",
-                    "reason")
-VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12);
-
--- name: GetEventsByWallet :many
-SELECT *
-FROM events
-WHERE wallet_address = $1;

modules/nodesale/database/postgresql/queries/nodes.sql

@@ -1,57 +0,0 @@
--- name: ClearDelegate :execrows
-UPDATE nodes
-SET "delegated_to" = ''
-WHERE "delegate_tx_hash" = '';
-
--- name: SetDelegates :execrows
-UPDATE nodes
-SET delegated_to = @delegatee, delegate_tx_hash = $3
-WHERE sale_block = $1 AND
-    sale_tx_index = $2 AND
-    node_id = ANY (@node_ids::int[]);
-
--- name: GetNodesByIds :many
-SELECT *
-FROM nodes
-WHERE sale_block = $1 AND
-    sale_tx_index = $2 AND
-    node_id = ANY (@node_ids::int[]);
-
-
--- name: GetNodesByOwner :many
-SELECT * 
-FROM nodes
-WHERE sale_block = $1 AND
-    sale_tx_index = $2 AND
-    owner_public_key = $3
-ORDER BY tier_index;
-
--- name: GetNodesByPubkey :many
-SELECT nodes.*
-FROM nodes JOIN events ON nodes.purchase_tx_hash = events.tx_hash
-WHERE sale_block = $1 AND
-    sale_tx_index = $2 AND
-    owner_public_key = $3 AND
-    delegated_to = $4;
-
--- name: CreateNode :exec
-INSERT INTO nodes (sale_block, sale_tx_index, node_id, tier_index, delegated_to, owner_public_key, purchase_tx_hash, delegate_tx_hash)
-VALUES ($1, $2, $3, $4, $5, $6, $7, $8);
-
--- name: GetNodeCountByTierIndex :many
-SELECT (tiers.tier_index)::int AS tier_index, count(nodes.tier_index)
-FROM generate_series(@from_tier::int,@to_tier::int) AS tiers(tier_index)
-LEFT JOIN 
-	(SELECT * 
-	FROM nodes 
-	WHERE sale_block = $1 AND 
-		sale_tx_index= $2) 
-	AS nodes ON tiers.tier_index = nodes.tier_index 
-GROUP BY tiers.tier_index
-ORDER BY tiers.tier_index;
-
--- name: GetNodesByDeployment :many
-SELECT * 
-FROM nodes
-WHERE sale_block = $1 AND
-    sale_tx_index = $2;

modules/nodesale/database/postgresql/queries/nodesales.sql

@@ -1,9 +0,0 @@
--- name: CreateNodeSale :exec
-INSERT INTO node_sales ("block_height", "tx_index", "name", "starts_at", "ends_at", "tiers", "seller_public_key", "max_per_address", "deploy_tx_hash", "max_discount_percentage", "seller_wallet")
-VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11);
-
--- name: GetNodeSale :many
-SELECT *
-FROM node_sales
-WHERE block_height = $1 AND
-    tx_index = $2;

modules/nodesale/database/postgresql/queries/test.sql

@@ -1,3 +0,0 @@
--- name: ClearEvents :exec
-DELETE FROM events
-WHERE tx_hash <> '';

modules/nodesale/datagateway/nodesale.go

@@ -1,77 +0,0 @@
-package datagateway
-
-import (
-	"context"
-
-	"github.com/gaze-network/indexer-network/modules/nodesale/internal/entity"
-)
-
-type NodeSaleDataGateway interface {
-	BeginNodeSaleTx(ctx context.Context) (NodeSaleDataGatewayWithTx, error)
-	CreateBlock(ctx context.Context, arg entity.Block) error
-	GetBlock(ctx context.Context, blockHeight int64) (*entity.Block, error)
-	GetLastProcessedBlock(ctx context.Context) (*entity.Block, error)
-	RemoveBlockFrom(ctx context.Context, fromBlock int64) (int64, error)
-	RemoveEventsFromBlock(ctx context.Context, fromBlock int64) (int64, error)
-	ClearDelegate(ctx context.Context) (int64, error)
-	GetNodesByIds(ctx context.Context, arg GetNodesByIdsParams) ([]entity.Node, error)
-	CreateEvent(ctx context.Context, arg entity.NodeSaleEvent) error
-	SetDelegates(ctx context.Context, arg SetDelegatesParams) (int64, error)
-	CreateNodeSale(ctx context.Context, arg entity.NodeSale) error
-	GetNodeSale(ctx context.Context, arg GetNodeSaleParams) ([]entity.NodeSale, error)
-	GetNodesByOwner(ctx context.Context, arg GetNodesByOwnerParams) ([]entity.Node, error)
-	CreateNode(ctx context.Context, arg entity.Node) error
-	GetNodeCountByTierIndex(ctx context.Context, arg GetNodeCountByTierIndexParams) ([]GetNodeCountByTierIndexRow, error)
-	GetNodesByPubkey(ctx context.Context, arg GetNodesByPubkeyParams) ([]entity.Node, error)
-	GetNodesByDeployment(ctx context.Context, saleBlock int64, saleTxIndex int32) ([]entity.Node, error)
-	GetEventsByWallet(ctx context.Context, walletAddress string) ([]entity.NodeSaleEvent, error)
-}
-
-type NodeSaleDataGatewayWithTx interface {
-	NodeSaleDataGateway
-	Tx
-}
-
-type GetNodesByIdsParams struct {
-	SaleBlock   uint64
-	SaleTxIndex uint32
-	NodeIds     []uint32
-}
-
-type SetDelegatesParams struct {
-	SaleBlock      uint64
-	SaleTxIndex    int32
-	Delegatee      string
-	DelegateTxHash string
-	NodeIds        []uint32
-}
-
-type GetNodeSaleParams struct {
-	BlockHeight uint64
-	TxIndex     uint32
-}
-
-type GetNodesByOwnerParams struct {
-	SaleBlock      uint64
-	SaleTxIndex    uint32
-	OwnerPublicKey string
-}
-
-type GetNodeCountByTierIndexParams struct {
-	SaleBlock   uint64
-	SaleTxIndex uint32
-	FromTier    uint32
-	ToTier      uint32
-}
-
-type GetNodeCountByTierIndexRow struct {
-	TierIndex int32
-	Count     int64
-}
-
-type GetNodesByPubkeyParams struct {
-	SaleBlock      int64
-	SaleTxIndex    int32
-	OwnerPublicKey string
-	DelegatedTo    string
-}

modules/nodesale/datagateway/tx.go

@@ -1,12 +0,0 @@
-package datagateway
-
-import "context"
-
-type Tx interface {
-	// Commit commits the DB transaction. All changes made after Begin() will be persisted. Calling Commit() will close the current transaction.
-	// If Commit() is called without a prior Begin(), it must be a no-op.
-	Commit(ctx context.Context) error
-	// Rollback rolls back the DB transaction. All changes made after Begin() will be discarded.
-	// Rollback() must be safe to call even if no transaction is active. Hence, a defer Rollback() is safe, even if Commit() was called prior with non-error conditions.
-	Rollback(ctx context.Context) error
-}

modules/nodesale/delegate.go

@@ -1,61 +0,0 @@
-package nodesale
-
-import (
-	"context"
-
-	"github.com/cockroachdb/errors"
-	"github.com/gaze-network/indexer-network/core/types"
-	"github.com/gaze-network/indexer-network/modules/nodesale/datagateway"
-	"github.com/gaze-network/indexer-network/modules/nodesale/internal/entity"
-	delegatevalidator "github.com/gaze-network/indexer-network/modules/nodesale/internal/validator/delegate"
-)
-
-func (p *Processor) ProcessDelegate(ctx context.Context, qtx datagateway.NodeSaleDataGatewayWithTx, block *types.Block, event NodeSaleEvent) error {
-	validator := delegatevalidator.New()
-	delegate := event.EventMessage.Delegate
-
-	_, nodes, err := validator.NodesExist(ctx, qtx, delegate.DeployID, delegate.NodeIDs)
-	if err != nil {
-		return errors.Wrap(err, "Cannot query")
-	}
-
-	for _, node := range nodes {
-		valid := validator.EqualXonlyPublicKey(node.OwnerPublicKey, event.TxPubkey)
-		if !valid {
-			break
-		}
-	}
-
-	err = qtx.CreateEvent(ctx, entity.NodeSaleEvent{
-		TxHash:         event.Transaction.TxHash.String(),
-		TxIndex:        int32(event.Transaction.Index),
-		Action:         int32(event.EventMessage.Action),
-		RawMessage:     event.RawData,
-		ParsedMessage:  event.EventJson,
-		BlockTimestamp: block.Header.Timestamp,
-		BlockHash:      event.Transaction.BlockHash.String(),
-		BlockHeight:    event.Transaction.BlockHeight,
-		Valid:          validator.Valid,
-		WalletAddress:  p.PubkeyToPkHashAddress(event.TxPubkey).EncodeAddress(),
-		Metadata:       nil,
-		Reason:         validator.Reason,
-	})
-	if err != nil {
-		return errors.Wrap(err, "Failed to insert event")
-	}
-
-	if validator.Valid {
-		_, err = qtx.SetDelegates(ctx, datagateway.SetDelegatesParams{
-			SaleBlock:      delegate.DeployID.Block,
-			SaleTxIndex:    int32(delegate.DeployID.TxIndex),
-			Delegatee:      delegate.DelegateePublicKey,
-			DelegateTxHash: event.Transaction.TxHash.String(),
-			NodeIds:        delegate.NodeIDs,
-		})
-		if err != nil {
-			return errors.Wrap(err, "Failed to set delegate")
-		}
-	}
-
-	return nil
-}

modules/nodesale/delegate_test.go

@@ -1,84 +0,0 @@
-package nodesale
-
-import (
-	"context"
-	"encoding/hex"
-	"testing"
-
-	"github.com/btcsuite/btcd/btcec/v2"
-	"github.com/gaze-network/indexer-network/common"
-	"github.com/gaze-network/indexer-network/modules/nodesale/datagateway"
-	"github.com/gaze-network/indexer-network/modules/nodesale/datagateway/mocks"
-	"github.com/gaze-network/indexer-network/modules/nodesale/internal/entity"
-	"github.com/gaze-network/indexer-network/modules/nodesale/protobuf"
-	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/require"
-)
-
-func TestDelegate(t *testing.T) {
-	ctx := context.Background()
-	mockDgTx := mocks.NewNodeSaleDataGatewayWithTx(t)
-	p := NewProcessor(mockDgTx, nil, common.NetworkMainnet, nil, 0)
-
-	buyerPrivateKey, _ := btcec.NewPrivateKey()
-	buyerPubkeyHex := hex.EncodeToString(buyerPrivateKey.PubKey().SerializeCompressed())
-
-	delegateePrivateKey, _ := btcec.NewPrivateKey()
-	delegateePubkeyHex := hex.EncodeToString(delegateePrivateKey.PubKey().SerializeCompressed())
-
-	delegateMessage := &protobuf.NodeSaleEvent{
-		Action: protobuf.Action_ACTION_DELEGATE,
-		Delegate: &protobuf.ActionDelegate{
-			DelegateePublicKey: delegateePubkeyHex,
-			NodeIDs:            []uint32{9, 10},
-			DeployID: &protobuf.ActionID{
-				Block:   uint64(testBlockHeight) - 2,
-				TxIndex: uint32(testTxIndex) - 2,
-			},
-		},
-	}
-
-	event, block := assembleTestEvent(buyerPrivateKey, "131313131313", "131313131313", 0, 0, delegateMessage)
-
-	mockDgTx.EXPECT().CreateEvent(mock.Anything, mock.MatchedBy(func(event entity.NodeSaleEvent) bool {
-		return event.Valid == true
-	})).Return(nil)
-
-	mockDgTx.EXPECT().GetNodesByIds(mock.Anything, datagateway.GetNodesByIdsParams{
-		SaleBlock:   delegateMessage.Delegate.DeployID.Block,
-		SaleTxIndex: delegateMessage.Delegate.DeployID.TxIndex,
-		NodeIds:     []uint32{9, 10},
-	}).Return([]entity.Node{
-		{
-			SaleBlock:      delegateMessage.Delegate.DeployID.Block,
-			SaleTxIndex:    delegateMessage.Delegate.DeployID.TxIndex,
-			NodeID:         9,
-			TierIndex:      1,
-			DelegatedTo:    "",
-			OwnerPublicKey: buyerPubkeyHex,
-			PurchaseTxHash: mock.Anything,
-			DelegateTxHash: "",
-		},
-		{
-			SaleBlock:      delegateMessage.Delegate.DeployID.Block,
-			SaleTxIndex:    delegateMessage.Delegate.DeployID.TxIndex,
-			NodeID:         10,
-			TierIndex:      2,
-			DelegatedTo:    "",
-			OwnerPublicKey: buyerPubkeyHex,
-			PurchaseTxHash: mock.Anything,
-			DelegateTxHash: "",
-		},
-	}, nil)
-
-	mockDgTx.EXPECT().SetDelegates(mock.Anything, datagateway.SetDelegatesParams{
-		SaleBlock:      delegateMessage.Delegate.DeployID.Block,
-		SaleTxIndex:    int32(delegateMessage.Delegate.DeployID.TxIndex),
-		Delegatee:      delegateMessage.Delegate.DelegateePublicKey,
-		DelegateTxHash: event.Transaction.TxHash.String(),
-		NodeIds:        delegateMessage.Delegate.NodeIDs,
-	}).Return(2, nil)
-
-	err := p.ProcessDelegate(ctx, mockDgTx, block, event)
-	require.NoError(t, err)
-}

modules/nodesale/deploy.go

@@ -1,67 +0,0 @@
-package nodesale
-
-import (
-	"context"
-	"time"
-
-	"github.com/cockroachdb/errors"
-	"github.com/gaze-network/indexer-network/core/types"
-	"github.com/gaze-network/indexer-network/modules/nodesale/datagateway"
-	"github.com/gaze-network/indexer-network/modules/nodesale/internal/entity"
-	"github.com/gaze-network/indexer-network/modules/nodesale/internal/validator"
-	"google.golang.org/protobuf/encoding/protojson"
-)
-
-func (p *Processor) ProcessDeploy(ctx context.Context, qtx datagateway.NodeSaleDataGatewayWithTx, block *types.Block, event NodeSaleEvent) error {
-	deploy := event.EventMessage.Deploy
-
-	validator := validator.New()
-
-	validator.EqualXonlyPublicKey(deploy.SellerPublicKey, event.TxPubkey)
-
-	err := qtx.CreateEvent(ctx, entity.NodeSaleEvent{
-		TxHash:         event.Transaction.TxHash.String(),
-		TxIndex:        int32(event.Transaction.Index),
-		Action:         int32(event.EventMessage.Action),
-		RawMessage:     event.RawData,
-		ParsedMessage:  event.EventJson,
-		BlockTimestamp: block.Header.Timestamp,
-		BlockHash:      event.Transaction.BlockHash.String(),
-		BlockHeight:    event.Transaction.BlockHeight,
-		Valid:          validator.Valid,
-		WalletAddress:  p.PubkeyToPkHashAddress(event.TxPubkey).EncodeAddress(),
-		Metadata:       nil,
-		Reason:         validator.Reason,
-	})
-	if err != nil {
-		return errors.Wrap(err, "Failed to insert event")
-	}
-	if validator.Valid {
-		tiers := make([][]byte, len(deploy.Tiers))
-		for i, tier := range deploy.Tiers {
-			tierJson, err := protojson.Marshal(tier)
-			if err != nil {
-				return errors.Wrap(err, "Failed to parse tiers to json")
-			}
-			tiers[i] = tierJson
-		}
-		err = qtx.CreateNodeSale(ctx, entity.NodeSale{
-			BlockHeight:           uint64(event.Transaction.BlockHeight),
-			TxIndex:               event.Transaction.Index,
-			Name:                  deploy.Name,
-			StartsAt:              time.Unix(int64(deploy.StartsAt), 0),
-			EndsAt:                time.Unix(int64(deploy.EndsAt), 0),
-			Tiers:                 tiers,
-			SellerPublicKey:       deploy.SellerPublicKey,
-			MaxPerAddress:         deploy.MaxPerAddress,
-			DeployTxHash:          event.Transaction.TxHash.String(),
-			MaxDiscountPercentage: int32(deploy.MaxDiscountPercentage),
-			SellerWallet:          deploy.SellerWallet,
-		})
-		if err != nil {
-			return errors.Wrap(err, "Failed to insert NodeSale")
-		}
-	}
-
-	return nil
-}

modules/nodesale/deploy_test.go

@@ -1,139 +0,0 @@
-package nodesale
-
-import (
-	"context"
-	"encoding/hex"
-	"testing"
-	"time"
-
-	"github.com/btcsuite/btcd/btcec/v2"
-	"github.com/gaze-network/indexer-network/common"
-	"github.com/gaze-network/indexer-network/modules/nodesale/datagateway/mocks"
-	"github.com/gaze-network/indexer-network/modules/nodesale/internal/entity"
-	"github.com/gaze-network/indexer-network/modules/nodesale/protobuf"
-	"github.com/samber/lo"
-	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/require"
-	"google.golang.org/protobuf/encoding/protojson"
-)
-
-func TestDeployInvalid(t *testing.T) {
-	ctx := context.Background()
-	mockDgTx := mocks.NewNodeSaleDataGatewayWithTx(t)
-	p := NewProcessor(mockDgTx, nil, common.NetworkMainnet, nil, 0)
-
-	prvKey, err := btcec.NewPrivateKey()
-	require.NoError(t, err)
-
-	strangerKey, err := btcec.NewPrivateKey()
-	require.NoError(t, err)
-
-	strangerPubkeyHex := hex.EncodeToString(strangerKey.PubKey().SerializeCompressed())
-
-	sellerWallet := p.PubkeyToPkHashAddress(prvKey.PubKey())
-
-	message := &protobuf.NodeSaleEvent{
-		Action: protobuf.Action_ACTION_DEPLOY,
-		Deploy: &protobuf.ActionDeploy{
-			Name:     t.Name(),
-			StartsAt: 100,
-			EndsAt:   200,
-			Tiers: []*protobuf.Tier{
-				{
-					PriceSat:      100,
-					Limit:         5,
-					MaxPerAddress: 100,
-				},
-				{
-					PriceSat:      200,
-					Limit:         5,
-					MaxPerAddress: 100,
-				},
-			},
-			SellerPublicKey:       strangerPubkeyHex,
-			MaxPerAddress:         100,
-			MaxDiscountPercentage: 50,
-			SellerWallet:          sellerWallet.EncodeAddress(),
-		},
-	}
-
-	event, block := assembleTestEvent(prvKey, "0101010101", "0101010101", 0, 0, message)
-
-	mockDgTx.EXPECT().CreateEvent(mock.Anything, mock.MatchedBy(func(event entity.NodeSaleEvent) bool {
-		return event.Valid == false
-	})).Return(nil)
-
-	err = p.ProcessDeploy(ctx, mockDgTx, block, event)
-	require.NoError(t, err)
-
-	mockDgTx.AssertNotCalled(t, "CreateNodeSale")
-}
-
-func TestDeployValid(t *testing.T) {
-	ctx := context.Background()
-	mockDgTx := mocks.NewNodeSaleDataGatewayWithTx(t)
-	p := NewProcessor(mockDgTx, nil, common.NetworkMainnet, nil, 0)
-
-	privateKey, err := btcec.NewPrivateKey()
-	require.NoError(t, err)
-
-	pubkeyHex := hex.EncodeToString(privateKey.PubKey().SerializeCompressed())
-
-	sellerWallet := p.PubkeyToPkHashAddress(privateKey.PubKey())
-
-	startAt := time.Now().Add(time.Hour * -1)
-	endAt := time.Now().Add(time.Hour * 1)
-
-	message := &protobuf.NodeSaleEvent{
-		Action: protobuf.Action_ACTION_DEPLOY,
-		Deploy: &protobuf.ActionDeploy{
-			Name:     t.Name(),
-			StartsAt: uint32(startAt.UTC().Unix()),
-			EndsAt:   uint32(endAt.UTC().Unix()),
-			Tiers: []*protobuf.Tier{
-				{
-					PriceSat:      100,
-					Limit:         5,
-					MaxPerAddress: 100,
-				},
-				{
-					PriceSat:      200,
-					Limit:         5,
-					MaxPerAddress: 100,
-				},
-			},
-			SellerPublicKey:       pubkeyHex,
-			MaxPerAddress:         100,
-			MaxDiscountPercentage: 50,
-			SellerWallet:          sellerWallet.EncodeAddress(),
-		},
-	}
-
-	event, block := assembleTestEvent(privateKey, "0202020202", "0202020202", 0, 0, message)
-
-	mockDgTx.EXPECT().CreateEvent(mock.Anything, mock.MatchedBy(func(event entity.NodeSaleEvent) bool {
-		return event.Valid == true
-	})).Return(nil)
-
-	tiers := lo.Map(message.Deploy.Tiers, func(tier *protobuf.Tier, _ int) []byte {
-		tierJson, err := protojson.Marshal(tier)
-		require.NoError(t, err)
-		return tierJson
-	})
-
-	mockDgTx.EXPECT().CreateNodeSale(mock.Anything, entity.NodeSale{
-		BlockHeight:           uint64(event.Transaction.BlockHeight),
-		TxIndex:               uint32(event.Transaction.Index),
-		Name:                  message.Deploy.Name,
-		StartsAt:              time.Unix(int64(message.Deploy.StartsAt), 0),
-		EndsAt:                time.Unix(int64(message.Deploy.EndsAt), 0),
-		Tiers:                 tiers,
-		SellerPublicKey:       message.Deploy.SellerPublicKey,
-		MaxPerAddress:         message.Deploy.MaxPerAddress,
-		DeployTxHash:          event.Transaction.TxHash.String(),
-		MaxDiscountPercentage: int32(message.Deploy.MaxDiscountPercentage),
-		SellerWallet:          message.Deploy.SellerWallet,
-	}).Return(nil)
-
-	p.ProcessDeploy(ctx, mockDgTx, block, event)
-}

modules/nodesale/internal/entity/entity.go

@@ -1,55 +0,0 @@
-package entity
-
-import "time"
-
-type Block struct {
-	BlockHeight int64
-	BlockHash   string
-	Module      string
-}
-
-type Node struct {
-	SaleBlock      uint64
-	SaleTxIndex    uint32
-	NodeID         uint32
-	TierIndex      int32
-	DelegatedTo    string
-	OwnerPublicKey string
-	PurchaseTxHash string
-	DelegateTxHash string
-}
-
-type NodeSale struct {
-	BlockHeight           uint64
-	TxIndex               uint32
-	Name                  string
-	StartsAt              time.Time
-	EndsAt                time.Time
-	Tiers                 [][]byte
-	SellerPublicKey       string
-	MaxPerAddress         uint32
-	DeployTxHash          string
-	MaxDiscountPercentage int32
-	SellerWallet          string
-}
-
-type NodeSaleEvent struct {
-	TxHash         string
-	BlockHeight    int64
-	TxIndex        int32
-	WalletAddress  string
-	Valid          bool
-	Action         int32
-	RawMessage     []byte
-	ParsedMessage  []byte
-	BlockTimestamp time.Time
-	BlockHash      string
-	Metadata       *MetadataEventPurchase
-	Reason         string
-}
-
-type MetadataEventPurchase struct {
-	ExpectedTotalAmountDiscounted uint64
-	ReportedTotalAmount           uint64
-	PaidTotalAmount               uint64
-}

modules/nodesale/internal/validator/delegate/validator.go

@@ -1,51 +0,0 @@
-package delegate
-
-import (
-	"context"
-
-	"github.com/cockroachdb/errors"
-	"github.com/gaze-network/indexer-network/modules/nodesale/datagateway"
-	"github.com/gaze-network/indexer-network/modules/nodesale/internal/entity"
-	"github.com/gaze-network/indexer-network/modules/nodesale/internal/validator"
-	"github.com/gaze-network/indexer-network/modules/nodesale/protobuf"
-)
-
-type DelegateValidator struct {
-	validator.Validator
-}
-
-func New() *DelegateValidator {
-	v := validator.New()
-	return &DelegateValidator{
-		Validator: *v,
-	}
-}
-
-func (v *DelegateValidator) NodesExist(
-	ctx context.Context,
-	qtx datagateway.NodeSaleDataGatewayWithTx,
-	deployId *protobuf.ActionID,
-	nodeIds []uint32,
-) (bool, []entity.Node, error) {
-	if !v.Valid {
-		return false, nil, nil
-	}
-
-	nodes, err := qtx.GetNodesByIds(ctx, datagateway.GetNodesByIdsParams{
-		SaleBlock:   deployId.Block,
-		SaleTxIndex: deployId.TxIndex,
-		NodeIds:     nodeIds,
-	})
-	if err != nil {
-		v.Valid = false
-		return v.Valid, nil, errors.Wrap(err, "Failed to get nodes")
-	}
-
-	if len(nodeIds) != len(nodes) {
-		v.Valid = false
-		return v.Valid, nil, nil
-	}
-
-	v.Valid = true
-	return v.Valid, nodes, nil
-}

modules/nodesale/internal/validator/errors.go

@@ -1,6 +0,0 @@
-package validator
-
-const (
-	INVALID_PUBKEY_FORMAT = "Cannot parse public key"
-	INVALID_PUBKEY        = "Invalid public key"
-)

modules/nodesale/internal/validator/purchase/errors.go

@@ -1,17 +0,0 @@
-package purchase
-
-const (
-	DEPLOYID_NOT_FOUND         = "Depoloy ID not found."
-	PURCHASE_TIMEOUT           = "Purchase timeout."
-	BLOCK_HEIGHT_TIMEOUT       = "Block height over timeout block"
-	INVALID_SIGNATURE_FORMAT   = "Cannot parse signature."
-	INVALID_SIGNATURE          = "Invalid Signature."
-	INVALID_TIER_JSON          = "Invalid Tier format"
-	INVALID_NODE_ID            = "Invalid NodeId."
-	NODE_ALREADY_PURCHASED     = "Some node has been purchased."
-	INVALID_SELLER_ADDR_FORMAT = "Invalid seller address."
-	INVALID_PAYMENT            = "Total amount paid less than reported price"
-	INSUFFICIENT_FUND          = "Insufficient fund"
-	OVER_LIMIT_PER_ADDR        = "Purchase over limit per address."
-	OVER_LIMIT_PER_TIER        = "Purchase over limit per tier."
-)

modules/nodesale/internal/validator/purchase/validator.go

@@ -1,283 +0,0 @@
-package purchase
-
-import (
-	"context"
-	"encoding/hex"
-	"slices"
-	"time"
-
-	"github.com/btcsuite/btcd/btcec/v2"
-	"github.com/btcsuite/btcd/btcec/v2/ecdsa"
-	"github.com/btcsuite/btcd/chaincfg"
-	"github.com/btcsuite/btcd/chaincfg/chainhash"
-	"github.com/cockroachdb/errors"
-	"github.com/gaze-network/indexer-network/modules/nodesale/datagateway"
-	"github.com/gaze-network/indexer-network/modules/nodesale/internal/entity"
-	"github.com/gaze-network/indexer-network/modules/nodesale/internal/validator"
-	"github.com/gaze-network/indexer-network/modules/nodesale/protobuf"
-	"google.golang.org/protobuf/encoding/protojson"
-	"google.golang.org/protobuf/proto"
-)
-
-type PurchaseValidator struct {
-	validator.Validator
-}
-
-func New() *PurchaseValidator {
-	v := validator.New()
-	return &PurchaseValidator{
-		Validator: *v,
-	}
-}
-
-func (v *PurchaseValidator) NodeSaleExists(ctx context.Context, qtx datagateway.NodeSaleDataGatewayWithTx, payload *protobuf.PurchasePayload) (bool, *entity.NodeSale, error) {
-	if !v.Valid {
-		return false, nil, nil
-	}
-	// check node existed
-	deploys, err := qtx.GetNodeSale(ctx, datagateway.GetNodeSaleParams{
-		BlockHeight: payload.DeployID.Block,
-		TxIndex:     payload.DeployID.TxIndex,
-	})
-	if err != nil {
-		v.Valid = false
-		return v.Valid, nil, errors.Wrap(err, "Failed to Get NodeSale")
-	}
-	if len(deploys) < 1 {
-		v.Valid = false
-		v.Reason = DEPLOYID_NOT_FOUND
-		return v.Valid, nil, nil
-	}
-	v.Valid = true
-	return v.Valid, &deploys[0], nil
-}
-
-func (v *PurchaseValidator) ValidTimestamp(deploy *entity.NodeSale, timestamp time.Time) bool {
-	if !v.Valid {
-		return false
-	}
-	if timestamp.Before(deploy.StartsAt) ||
-		timestamp.After(deploy.EndsAt) {
-		v.Valid = false
-		v.Reason = PURCHASE_TIMEOUT
-		return v.Valid
-	}
-	v.Valid = true
-	return v.Valid
-}
-
-func (v *PurchaseValidator) WithinTimeoutBlock(timeOutBlock uint64, blockHeight uint64) bool {
-	if !v.Valid {
-		return false
-	}
-	if timeOutBlock == 0 {
-		// No timeout
-		v.Valid = true
-		return v.Valid
-	}
-	if timeOutBlock < blockHeight {
-		v.Valid = false
-		v.Reason = BLOCK_HEIGHT_TIMEOUT
-		return v.Valid
-	}
-	v.Valid = true
-	return v.Valid
-}
-
-func (v *PurchaseValidator) VerifySignature(purchase *protobuf.ActionPurchase, deploy *entity.NodeSale) bool {
-	if !v.Valid {
-		return false
-	}
-	payload := purchase.Payload
-	payloadBytes, _ := proto.Marshal(payload)
-	signatureBytes, _ := hex.DecodeString(purchase.SellerSignature)
-	signature, err := ecdsa.ParseSignature(signatureBytes)
-	if err != nil {
-		v.Valid = false
-		v.Reason = INVALID_SIGNATURE_FORMAT
-		return v.Valid
-	}
-	hash := chainhash.DoubleHashB(payloadBytes)
-	pubkeyBytes, _ := hex.DecodeString(deploy.SellerPublicKey)
-	pubKey, _ := btcec.ParsePubKey(pubkeyBytes)
-	verified := signature.Verify(hash[:], pubKey)
-	if !verified {
-		v.Valid = false
-		v.Reason = INVALID_SIGNATURE
-		return v.Valid
-	}
-	v.Valid = true
-	return v.Valid
-}
-
-type TierMap struct {
-	Tiers            []protobuf.Tier
-	BuyingTiersCount []uint32
-	NodeIdToTier     map[uint32]int32
-}
-
-func (v *PurchaseValidator) ValidTiers(
-	payload *protobuf.PurchasePayload,
-	deploy *entity.NodeSale,
-) (bool, TierMap) {
-	if !v.Valid {
-		return false, TierMap{}
-	}
-	tiers := make([]protobuf.Tier, len(deploy.Tiers))
-	buyingTiersCount := make([]uint32, len(tiers))
-	nodeIdToTier := make(map[uint32]int32)
-
-	for i, tierJson := range deploy.Tiers {
-		tier := &tiers[i]
-		err := protojson.Unmarshal(tierJson, tier)
-		if err != nil {
-			v.Valid = false
-			v.Reason = INVALID_TIER_JSON
-			return v.Valid, TierMap{}
-		}
-	}
-
-	slices.Sort(payload.NodeIDs)
-
-	var currentTier int32 = -1
-	var tierSum uint32 = 0
-	for _, nodeId := range payload.NodeIDs {
-		for nodeId >= tierSum && currentTier < int32(len(tiers)-1) {
-			currentTier++
-			tierSum += tiers[currentTier].Limit
-		}
-		if nodeId < tierSum {
-			buyingTiersCount[currentTier]++
-			nodeIdToTier[nodeId] = currentTier
-		} else {
-			v.Valid = false
-			v.Reason = INVALID_NODE_ID
-			return false, TierMap{}
-		}
-	}
-	v.Valid = true
-	return v.Valid, TierMap{
-		Tiers:            tiers,
-		BuyingTiersCount: buyingTiersCount,
-		NodeIdToTier:     nodeIdToTier,
-	}
-}
-
-func (v *PurchaseValidator) ValidUnpurchasedNodes(
-	ctx context.Context,
-	qtx datagateway.NodeSaleDataGatewayWithTx,
-	payload *protobuf.PurchasePayload,
-) (bool, error) {
-	if !v.Valid {
-		return false, nil
-	}
-
-	// valid unpurchased node ID
-	nodes, err := qtx.GetNodesByIds(ctx, datagateway.GetNodesByIdsParams{
-		SaleBlock:   payload.DeployID.Block,
-		SaleTxIndex: payload.DeployID.TxIndex,
-		NodeIds:     payload.NodeIDs,
-	})
-	if err != nil {
-		v.Valid = false
-		return v.Valid, errors.Wrap(err, "Failed to Get nodes")
-	}
-	if len(nodes) > 0 {
-		v.Valid = false
-		v.Reason = NODE_ALREADY_PURCHASED
-		return false, nil
-	}
-	v.Valid = true
-	return true, nil
-}
-
-func (v *PurchaseValidator) ValidPaidAmount(
-	payload *protobuf.PurchasePayload,
-	deploy *entity.NodeSale,
-	txPaid uint64,
-	tiers []protobuf.Tier,
-	buyingTiersCount []uint32,
-	network *chaincfg.Params,
-) (bool, *entity.MetadataEventPurchase) {
-	if !v.Valid {
-		return false, nil
-	}
-
-	meta := entity.MetadataEventPurchase{}
-
-	meta.PaidTotalAmount = txPaid
-	meta.ReportedTotalAmount = uint64(payload.TotalAmountSat)
-	// total amount paid is greater than report paid
-	if txPaid < uint64(payload.TotalAmountSat) {
-		v.Valid = false
-		v.Reason = INVALID_PAYMENT
-		return v.Valid, nil
-	}
-	// calculate total price
-	var totalPrice uint64 = 0
-	for i := 0; i < len(tiers); i++ {
-		totalPrice += uint64(buyingTiersCount[i] * tiers[i].PriceSat)
-	}
-	// report paid is greater than max discounted total price
-	maxDiscounted := totalPrice * (100 - uint64(deploy.MaxDiscountPercentage))
-	decimal := maxDiscounted % 100
-	maxDiscounted /= 100
-	if decimal%100 >= 50 {
-		maxDiscounted++
-	}
-	meta.ExpectedTotalAmountDiscounted = maxDiscounted
-	if uint64(payload.TotalAmountSat) < maxDiscounted {
-		v.Valid = false
-		v.Reason = INSUFFICIENT_FUND
-		return v.Valid, nil
-	}
-	v.Valid = true
-	return v.Valid, &meta
-}
-
-func (v *PurchaseValidator) WithinLimit(
-	ctx context.Context,
-	qtx datagateway.NodeSaleDataGatewayWithTx,
-	payload *protobuf.PurchasePayload,
-	deploy *entity.NodeSale,
-	tiers []protobuf.Tier,
-	buyingTiersCount []uint32,
-) (bool, error) {
-	if !v.Valid {
-		return false, nil
-	}
-
-	// check node limit
-	// get all selled by seller and owned by buyer
-	buyerOwnedNodes, err := qtx.GetNodesByOwner(ctx, datagateway.GetNodesByOwnerParams{
-		SaleBlock:      deploy.BlockHeight,
-		SaleTxIndex:    deploy.TxIndex,
-		OwnerPublicKey: payload.BuyerPublicKey,
-	})
-	if err != nil {
-		v.Valid = false
-		return v.Valid, errors.Wrap(err, "Failed to GetNodesByOwner")
-	}
-	if len(buyerOwnedNodes)+len(payload.NodeIDs) > int(deploy.MaxPerAddress) {
-		v.Valid = false
-		v.Reason = "Purchase over limit per address."
-		return v.Valid, nil
-	}
-
-	// check limit
-	// count each tiers
-	// check limited for each tier
-	ownedTiersCount := make([]uint32, len(tiers))
-	for _, node := range buyerOwnedNodes {
-		ownedTiersCount[node.TierIndex]++
-	}
-	for i := 0; i < len(tiers); i++ {
-		if ownedTiersCount[i]+buyingTiersCount[i] > tiers[i].MaxPerAddress {
-			v.Valid = false
-			v.Reason = "Purchase over limit per tier."
-			return v.Valid, nil
-		}
-	}
-	v.Valid = true
-	return v.Valid, nil
-}

modules/nodesale/internal/validator/validator.go

@@ -1,44 +0,0 @@
-package validator
-
-import (
-	"bytes"
-	"encoding/hex"
-
-	"github.com/btcsuite/btcd/btcec/v2"
-)
-
-type Validator struct {
-	Valid  bool
-	Reason string
-}
-
-func New() *Validator {
-	return &Validator{
-		Valid: true,
-	}
-}
-
-func (v *Validator) EqualXonlyPublicKey(target string, expected *btcec.PublicKey) bool {
-	if !v.Valid {
-		return false
-	}
-	targetBytes, err := hex.DecodeString(target)
-	if err != nil {
-		v.Valid = false
-		v.Reason = INVALID_PUBKEY_FORMAT
-	}
-
-	targetPubKey, err := btcec.ParsePubKey(targetBytes)
-	if err != nil {
-		v.Valid = false
-		v.Reason = INVALID_PUBKEY_FORMAT
-	}
-	xOnlyTargetPubKey := btcec.ToSerialized(targetPubKey).SchnorrSerialized()
-	xOnlyExpectedPubKey := btcec.ToSerialized(expected).SchnorrSerialized()
-
-	v.Valid = bytes.Equal(xOnlyTargetPubKey[:], xOnlyExpectedPubKey[:])
-	if !v.Valid {
-		v.Reason = INVALID_PUBKEY
-	}
-	return v.Valid
-}

modules/nodesale/nodesale.go

@@ -1,61 +0,0 @@
-package nodesale
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/btcsuite/btcd/rpcclient"
-	"github.com/gaze-network/indexer-network/core/datasources"
-	"github.com/gaze-network/indexer-network/core/indexer"
-	"github.com/gaze-network/indexer-network/internal/config"
-	"github.com/gaze-network/indexer-network/internal/postgres"
-	"github.com/gaze-network/indexer-network/modules/nodesale/api/httphandler"
-	repository "github.com/gaze-network/indexer-network/modules/nodesale/repository/postgres"
-	"github.com/gaze-network/indexer-network/pkg/logger"
-	"github.com/gofiber/fiber/v2"
-	"github.com/samber/do/v2"
-)
-
-var NODESALE_MAGIC = []byte{0x6e, 0x73, 0x6f, 0x70}
-
-const (
-	Version = "v0.0.1-alpha"
-)
-
-func New(injector do.Injector) (indexer.IndexerWorker, error) {
-	ctx := do.MustInvoke[context.Context](injector)
-	conf := do.MustInvoke[config.Config](injector)
-
-	btcClient := do.MustInvoke[*rpcclient.Client](injector)
-	datasource := datasources.NewBitcoinNode(btcClient)
-
-	pg, err := postgres.NewPool(ctx, conf.Modules.NodeSale.Postgres)
-	if err != nil {
-		return nil, fmt.Errorf("Can't create postgres connection : %w", err)
-	}
-	var cleanupFuncs []func(context.Context) error
-	cleanupFuncs = append(cleanupFuncs, func(ctx context.Context) error {
-		pg.Close()
-		return nil
-	})
-	repository := repository.NewRepository(pg)
-
-	processor := &Processor{
-		NodeSaleDg:       repository,
-		BtcClient:        datasource,
-		Network:          conf.Network,
-		cleanupFuncs:     cleanupFuncs,
-		lastBlockDefault: conf.Modules.NodeSale.LastBlockDefault,
-	}
-
-	httpServer := do.MustInvoke[*fiber.App](injector)
-	nodeSaleHandler := httphandler.New(repository)
-	if err := nodeSaleHandler.Mount(httpServer); err != nil {
-		return nil, fmt.Errorf("Can't mount nodesale API : %w", err)
-	}
-	logger.InfoContext(ctx, "Mounted nodesale HTTP handler")
-
-	indexer := indexer.New(processor, datasource)
-	logger.InfoContext(ctx, "NodeSale module started.")
-	return indexer, nil
-}

modules/nodesale/nodesale_test.go

@@ -1,61 +0,0 @@
-package nodesale
-
-import (
-	"time"
-
-	"github.com/btcsuite/btcd/chaincfg/chainhash"
-	"github.com/btcsuite/btcd/txscript"
-	"github.com/decred/dcrd/dcrec/secp256k1/v4"
-	"github.com/gaze-network/indexer-network/core/types"
-	"github.com/gaze-network/indexer-network/modules/nodesale/protobuf"
-	"google.golang.org/protobuf/encoding/protojson"
-	"google.golang.org/protobuf/proto"
-)
-
-var (
-	testBlockHeight uint64 = 101
-	testTxIndex     uint32 = 1
-)
-
-func assembleTestEvent(privateKey *secp256k1.PrivateKey, blockHashHex, txHashHex string, blockHeight uint64, txIndex uint32, message *protobuf.NodeSaleEvent) (NodeSaleEvent, *types.Block) {
-	blockHash, _ := chainhash.NewHashFromStr(blockHashHex)
-	txHash, _ := chainhash.NewHashFromStr(txHashHex)
-
-	rawData, _ := proto.Marshal(message)
-
-	builder := txscript.NewScriptBuilder()
-	builder.AddOp(txscript.OP_FALSE)
-	builder.AddOp(txscript.OP_IF)
-	builder.AddData(rawData)
-	builder.AddOp(txscript.OP_ENDIF)
-
-	messageJson, _ := protojson.Marshal(message)
-
-	if blockHeight == 0 {
-		blockHeight = testBlockHeight
-		testBlockHeight++
-	}
-	if txIndex == 0 {
-		txIndex = testTxIndex
-		testTxIndex++
-	}
-
-	event := NodeSaleEvent{
-		Transaction: &types.Transaction{
-			BlockHeight: int64(blockHeight),
-			BlockHash:   *blockHash,
-			Index:       uint32(txIndex),
-			TxHash:      *txHash,
-		},
-		RawData:      rawData,
-		EventMessage: message,
-		EventJson:    messageJson,
-		TxPubkey:     privateKey.PubKey(),
-	}
-	block := &types.Block{
-		Header: types.BlockHeader{
-			Timestamp: time.Now().UTC(),
-		},
-	}
-	return event, block
-}

modules/nodesale/processor.go

@@ -1,303 +0,0 @@
-package nodesale
-
-import (
-	"bytes"
-	"context"
-
-	"github.com/btcsuite/btcd/btcec/v2"
-	"github.com/btcsuite/btcd/chaincfg/chainhash"
-	"github.com/btcsuite/btcd/txscript"
-	"github.com/gaze-network/indexer-network/common"
-	"github.com/gaze-network/indexer-network/core/indexer"
-	"github.com/gaze-network/indexer-network/core/types"
-	"github.com/gaze-network/indexer-network/pkg/logger"
-	"github.com/gaze-network/indexer-network/pkg/logger/slogx"
-	"google.golang.org/protobuf/encoding/protojson"
-	"google.golang.org/protobuf/proto"
-
-	"github.com/cockroachdb/errors"
-	"github.com/gaze-network/indexer-network/core/datasources"
-	"github.com/gaze-network/indexer-network/modules/nodesale/datagateway"
-	"github.com/gaze-network/indexer-network/modules/nodesale/internal/entity"
-	"github.com/gaze-network/indexer-network/modules/nodesale/protobuf"
-)
-
-type NodeSaleEvent struct {
-	Transaction  *types.Transaction
-	EventMessage *protobuf.NodeSaleEvent
-	EventJson    []byte
-	TxPubkey     *btcec.PublicKey
-	RawData      []byte
-	InputValue   uint64
-}
-
-func NewProcessor(repository datagateway.NodeSaleDataGateway,
-	datasource *datasources.BitcoinNodeDatasource,
-	network common.Network,
-	cleanupFuncs []func(context.Context) error,
-	lastBlockDefault int64,
-) *Processor {
-	return &Processor{
-		NodeSaleDg:       repository,
-		BtcClient:        datasource,
-		Network:          network,
-		cleanupFuncs:     cleanupFuncs,
-		lastBlockDefault: lastBlockDefault,
-	}
-}
-
-func (p *Processor) Shutdown(ctx context.Context) error {
-	for _, cleanupFunc := range p.cleanupFuncs {
-		err := cleanupFunc(ctx)
-		if err != nil {
-			return errors.Wrap(err, "cleanup function error")
-		}
-	}
-	return nil
-}
-
-type Processor struct {
-	NodeSaleDg       datagateway.NodeSaleDataGateway
-	BtcClient        *datasources.BitcoinNodeDatasource
-	Network          common.Network
-	cleanupFuncs     []func(context.Context) error
-	lastBlockDefault int64
-}
-
-// CurrentBlock implements indexer.Processor.
-func (p *Processor) CurrentBlock(ctx context.Context) (types.BlockHeader, error) {
-	block, err := p.NodeSaleDg.GetLastProcessedBlock(ctx)
-	if err != nil {
-		logger.InfoContext(ctx, "Couldn't get last processed block. Start from NODESALE_LAST_BLOCK_DEFAULT.",
-			slogx.Int64("currentBlock", p.lastBlockDefault))
-		header, err := p.BtcClient.GetBlockHeader(ctx, p.lastBlockDefault)
-		if err != nil {
-			return types.BlockHeader{}, errors.Wrap(err, "Cannot get default block from bitcoin node")
-		}
-		return types.BlockHeader{
-			Hash:   header.Hash,
-			Height: p.lastBlockDefault,
-		}, nil
-	}
-
-	hash, err := chainhash.NewHashFromStr(block.BlockHash)
-	if err != nil {
-		logger.PanicContext(ctx, "Invalid hash format found in Database.")
-	}
-	return types.BlockHeader{
-		Hash:   *hash,
-		Height: block.BlockHeight,
-	}, nil
-}
-
-// GetIndexedBlock implements indexer.Processor.
-func (p *Processor) GetIndexedBlock(ctx context.Context, height int64) (types.BlockHeader, error) {
-	block, err := p.NodeSaleDg.GetBlock(ctx, height)
-	if err != nil {
-		return types.BlockHeader{}, errors.Wrapf(err, "Block %d not found", height)
-	}
-	hash, err := chainhash.NewHashFromStr(block.BlockHash)
-	if err != nil {
-		logger.PanicContext(ctx, "Invalid hash format found in Database.")
-	}
-	return types.BlockHeader{
-		Hash:   *hash,
-		Height: block.BlockHeight,
-	}, nil
-}
-
-// Name implements indexer.Processor.
-func (p *Processor) Name() string {
-	return "nodesale"
-}
-
-func extractNodeSaleData(witness [][]byte) (data []byte, internalPubkey *btcec.PublicKey, isNodeSale bool) {
-	tokenizer, controlBlock, isTapScript := extractTapScript(witness)
-	if !isTapScript {
-		return []byte{}, nil, false
-	}
-	state := 0
-	for tokenizer.Next() {
-		switch state {
-		case 0:
-			if tokenizer.Opcode() == txscript.OP_0 {
-				state++
-			} else {
-				state = 0
-			}
-		case 1:
-			if tokenizer.Opcode() == txscript.OP_IF {
-				state++
-			} else {
-				state = 0
-			}
-		case 2:
-			if tokenizer.Opcode() == txscript.OP_DATA_4 &&
-				bytes.Equal(tokenizer.Data(), NODESALE_MAGIC) {
-				state++
-			} else {
-				state = 0
-			}
-		case 3:
-			// Any instruction > txscript.OP_16 is not push data. Note: txscript.OP_PUSHDATAX < txscript.OP_16
-			if tokenizer.Opcode() <= txscript.OP_16 {
-				data := tokenizer.Data()
-				return data, controlBlock.InternalKey, true
-			}
-			state = 0
-		}
-	}
-	return []byte{}, nil, false
-}
-
-func (p *Processor) parseTransactions(ctx context.Context, transactions []*types.Transaction) ([]NodeSaleEvent, error) {
-	var events []NodeSaleEvent
-	for _, t := range transactions {
-		for _, txIn := range t.TxIn {
-			data, txPubkey, isNodeSale := extractNodeSaleData(txIn.Witness)
-			if !isNodeSale {
-				continue
-			}
-
-			event := &protobuf.NodeSaleEvent{}
-			err := proto.Unmarshal(data, event)
-			if err != nil {
-				logger.WarnContext(ctx, "Invalid Protobuf",
-					slogx.String("block_hash", t.BlockHash.String()),
-					slogx.Int("txIndex", int(t.Index)))
-				continue
-			}
-			eventJson, err := protojson.Marshal(event)
-			if err != nil {
-				return []NodeSaleEvent{}, errors.Wrap(err, "Failed to parse protobuf to json")
-			}
-
-			prevTx, _, err := p.BtcClient.GetRawTransactionAndHeightByTxHash(ctx, txIn.PreviousOutTxHash)
-			if err != nil {
-				return nil, errors.Wrap(err, "Failed to get Previous transaction data")
-			}
-
-			if txIn.PreviousOutIndex >= uint32(len(prevTx.TxOut)) {
-				return nil, errors.Wrap(err, "Invalid previous transaction from bitcoin")
-			}
-
-			events = append(events, NodeSaleEvent{
-				Transaction:  t,
-				EventMessage: event,
-				EventJson:    eventJson,
-				RawData:      data,
-				TxPubkey:     txPubkey,
-				InputValue:   uint64(prevTx.TxOut[txIn.PreviousOutIndex].Value),
-			})
-		}
-	}
-	return events, nil
-}
-
-// Process implements indexer.Processor.
-func (p *Processor) Process(ctx context.Context, inputs []*types.Block) error {
-	for _, block := range inputs {
-		logger.InfoContext(ctx, "NodeSale processing a block",
-			slogx.Int64("block", block.Header.Height),
-			slogx.Stringer("hash", block.Header.Hash))
-		// parse all event from each transaction including reading tx wallet
-		events, err := p.parseTransactions(ctx, block.Transactions)
-		if err != nil {
-			return errors.Wrap(err, "Invalid data from bitcoin client")
-		}
-		// open transaction
-		qtx, err := p.NodeSaleDg.BeginNodeSaleTx(ctx)
-		if err != nil {
-			return errors.Wrap(err, "Failed to create transaction")
-		}
-		defer func() {
-			err = qtx.Rollback(ctx)
-			if err != nil {
-				logger.PanicContext(ctx, "Failed to rollback db")
-			}
-		}()
-
-		// write block
-		err = qtx.CreateBlock(ctx, entity.Block{
-			BlockHeight: block.Header.Height,
-			BlockHash:   block.Header.Hash.String(),
-			Module:      p.Name(),
-		})
-		if err != nil {
-			return errors.Wrapf(err, "Failed to add block %d", block.Header.Height)
-		}
-		// for each events
-		for _, event := range events {
-			logger.InfoContext(ctx, "NodeSale processing event",
-				slogx.Uint32("txIndex", event.Transaction.Index),
-				slogx.Int64("blockHeight", block.Header.Height),
-				slogx.Stringer("blockhash", block.Header.Hash),
-			)
-			eventMessage := event.EventMessage
-			switch eventMessage.Action {
-			case protobuf.Action_ACTION_DEPLOY:
-				err = p.ProcessDeploy(ctx, qtx, block, event)
-				if err != nil {
-					return errors.Wrapf(err, "Failed to deploy at block %d", block.Header.Height)
-				}
-			case protobuf.Action_ACTION_DELEGATE:
-				err = p.ProcessDelegate(ctx, qtx, block, event)
-				if err != nil {
-					return errors.Wrapf(err, "Failed to delegate at block %d", block.Header.Height)
-				}
-			case protobuf.Action_ACTION_PURCHASE:
-				err = p.ProcessPurchase(ctx, qtx, block, event)
-				if err != nil {
-					return errors.Wrapf(err, "Failed to purchase at block %d", block.Header.Height)
-				}
-			default:
-				logger.DebugContext(ctx, "Invalid event ACTION", slogx.Stringer("txHash", (event.Transaction.TxHash)))
-			}
-		}
-		// close transaction
-		err = qtx.Commit(ctx)
-		if err != nil {
-			return errors.Wrap(err, "Failed to commit transaction")
-		}
-		logger.InfoContext(ctx, "NodeSale finished processing block",
-			slogx.Int64("block", block.Header.Height),
-			slogx.Stringer("hash", block.Header.Hash))
-	}
-	return nil
-}
-
-// RevertData implements indexer.Processor.
-func (p *Processor) RevertData(ctx context.Context, from int64) error {
-	qtx, err := p.NodeSaleDg.BeginNodeSaleTx(ctx)
-	if err != nil {
-		return errors.Wrap(err, "Failed to create transaction")
-	}
-	defer func() { err = qtx.Rollback(ctx) }()
-	_, err = qtx.RemoveBlockFrom(ctx, from)
-	if err != nil {
-		return errors.Wrap(err, "Failed to remove blocks.")
-	}
-
-	affected, err := qtx.RemoveEventsFromBlock(ctx, from)
-	if err != nil {
-		return errors.Wrap(err, "Failed to remove events.")
-	}
-	_, err = qtx.ClearDelegate(ctx)
-	if err != nil {
-		return errors.Wrap(err, "Failed to clear delegate from nodes")
-	}
-	err = qtx.Commit(ctx)
-	if err != nil {
-		return errors.Wrap(err, "Failed to commit transaction")
-	}
-	logger.InfoContext(ctx, "Events removed",
-		slogx.Int64("Total removed", affected))
-	return nil
-}
-
-// VerifyStates implements indexer.Processor.
-func (p *Processor) VerifyStates(ctx context.Context) error {
-	panic("unimplemented")
-}
-
-var _ indexer.Processor[*types.Block] = (*Processor)(nil)

modules/nodesale/protobuf/nodesale.pb.go

@@ -1,806 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// versions:
-// 	protoc-gen-go v1.34.1
-// 	protoc        v5.26.1
-// source: modules/nodesale/protobuf/nodesale.proto
-
-// protoc modules/nodesale/protobuf/nodesale.proto --go_out=. --go_opt=module=github.com/gaze-network/indexer-network
-
-package protobuf
-
-import (
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	reflect "reflect"
-	sync "sync"
-)
-
-const (
-	// Verify that this generated code is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
-	// Verify that runtime/protoimpl is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
-)
-
-type Action int32
-
-const (
-	Action_ACTION_DEPLOY   Action = 0
-	Action_ACTION_PURCHASE Action = 1
-	Action_ACTION_DELEGATE Action = 2
-)
-
-// Enum value maps for Action.
-var (
-	Action_name = map[int32]string{
-		0: "ACTION_DEPLOY",
-		1: "ACTION_PURCHASE",
-		2: "ACTION_DELEGATE",
-	}
-	Action_value = map[string]int32{
-		"ACTION_DEPLOY":   0,
-		"ACTION_PURCHASE": 1,
-		"ACTION_DELEGATE": 2,
-	}
-)
-
-func (x Action) Enum() *Action {
-	p := new(Action)
-	*p = x
-	return p
-}
-
-func (x Action) String() string {
-	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
-}
-
-func (Action) Descriptor() protoreflect.EnumDescriptor {
-	return file_modules_nodesale_protobuf_nodesale_proto_enumTypes[0].Descriptor()
-}
-
-func (Action) Type() protoreflect.EnumType {
-	return &file_modules_nodesale_protobuf_nodesale_proto_enumTypes[0]
-}
-
-func (x Action) Number() protoreflect.EnumNumber {
-	return protoreflect.EnumNumber(x)
-}
-
-// Deprecated: Use Action.Descriptor instead.
-func (Action) EnumDescriptor() ([]byte, []int) {
-	return file_modules_nodesale_protobuf_nodesale_proto_rawDescGZIP(), []int{0}
-}
-
-type NodeSaleEvent struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Action   Action          `protobuf:"varint,1,opt,name=action,proto3,enum=nodesale.Action" json:"action,omitempty"`
-	Deploy   *ActionDeploy   `protobuf:"bytes,2,opt,name=deploy,proto3,oneof" json:"deploy,omitempty"`
-	Purchase *ActionPurchase `protobuf:"bytes,3,opt,name=purchase,proto3,oneof" json:"purchase,omitempty"`
-	Delegate *ActionDelegate `protobuf:"bytes,4,opt,name=delegate,proto3,oneof" json:"delegate,omitempty"`
-}
-
-func (x *NodeSaleEvent) Reset() {
-	*x = NodeSaleEvent{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_modules_nodesale_protobuf_nodesale_proto_msgTypes[0]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *NodeSaleEvent) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*NodeSaleEvent) ProtoMessage() {}
-
-func (x *NodeSaleEvent) ProtoReflect() protoreflect.Message {
-	mi := &file_modules_nodesale_protobuf_nodesale_proto_msgTypes[0]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use NodeSaleEvent.ProtoReflect.Descriptor instead.
-func (*NodeSaleEvent) Descriptor() ([]byte, []int) {
-	return file_modules_nodesale_protobuf_nodesale_proto_rawDescGZIP(), []int{0}
-}
-
-func (x *NodeSaleEvent) GetAction() Action {
-	if x != nil {
-		return x.Action
-	}
-	return Action_ACTION_DEPLOY
-}
-
-func (x *NodeSaleEvent) GetDeploy() *ActionDeploy {
-	if x != nil {
-		return x.Deploy
-	}
-	return nil
-}
-
-func (x *NodeSaleEvent) GetPurchase() *ActionPurchase {
-	if x != nil {
-		return x.Purchase
-	}
-	return nil
-}
-
-func (x *NodeSaleEvent) GetDelegate() *ActionDelegate {
-	if x != nil {
-		return x.Delegate
-	}
-	return nil
-}
-
-type ActionDeploy struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Name                  string  `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
-	StartsAt              uint32  `protobuf:"varint,2,opt,name=startsAt,proto3" json:"startsAt,omitempty"`
-	EndsAt                uint32  `protobuf:"varint,3,opt,name=endsAt,proto3" json:"endsAt,omitempty"`
-	Tiers                 []*Tier `protobuf:"bytes,4,rep,name=tiers,proto3" json:"tiers,omitempty"`
-	SellerPublicKey       string  `protobuf:"bytes,5,opt,name=sellerPublicKey,proto3" json:"sellerPublicKey,omitempty"`
-	MaxPerAddress         uint32  `protobuf:"varint,6,opt,name=maxPerAddress,proto3" json:"maxPerAddress,omitempty"`
-	MaxDiscountPercentage uint32  `protobuf:"varint,7,opt,name=maxDiscountPercentage,proto3" json:"maxDiscountPercentage,omitempty"`
-	SellerWallet          string  `protobuf:"bytes,8,opt,name=sellerWallet,proto3" json:"sellerWallet,omitempty"`
-}
-
-func (x *ActionDeploy) Reset() {
-	*x = ActionDeploy{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_modules_nodesale_protobuf_nodesale_proto_msgTypes[1]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *ActionDeploy) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*ActionDeploy) ProtoMessage() {}
-
-func (x *ActionDeploy) ProtoReflect() protoreflect.Message {
-	mi := &file_modules_nodesale_protobuf_nodesale_proto_msgTypes[1]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use ActionDeploy.ProtoReflect.Descriptor instead.
-func (*ActionDeploy) Descriptor() ([]byte, []int) {
-	return file_modules_nodesale_protobuf_nodesale_proto_rawDescGZIP(), []int{1}
-}
-
-func (x *ActionDeploy) GetName() string {
-	if x != nil {
-		return x.Name
-	}
-	return ""
-}
-
-func (x *ActionDeploy) GetStartsAt() uint32 {
-	if x != nil {
-		return x.StartsAt
-	}
-	return 0
-}
-
-func (x *ActionDeploy) GetEndsAt() uint32 {
-	if x != nil {
-		return x.EndsAt
-	}
-	return 0
-}
-
-func (x *ActionDeploy) GetTiers() []*Tier {
-	if x != nil {
-		return x.Tiers
-	}
-	return nil
-}
-
-func (x *ActionDeploy) GetSellerPublicKey() string {
-	if x != nil {
-		return x.SellerPublicKey
-	}
-	return ""
-}
-
-func (x *ActionDeploy) GetMaxPerAddress() uint32 {
-	if x != nil {
-		return x.MaxPerAddress
-	}
-	return 0
-}
-
-func (x *ActionDeploy) GetMaxDiscountPercentage() uint32 {
-	if x != nil {
-		return x.MaxDiscountPercentage
-	}
-	return 0
-}
-
-func (x *ActionDeploy) GetSellerWallet() string {
-	if x != nil {
-		return x.SellerWallet
-	}
-	return ""
-}
-
-type Tier struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	PriceSat      uint32 `protobuf:"varint,1,opt,name=priceSat,proto3" json:"priceSat,omitempty"`
-	Limit         uint32 `protobuf:"varint,2,opt,name=limit,proto3" json:"limit,omitempty"`
-	MaxPerAddress uint32 `protobuf:"varint,3,opt,name=maxPerAddress,proto3" json:"maxPerAddress,omitempty"`
-}
-
-func (x *Tier) Reset() {
-	*x = Tier{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_modules_nodesale_protobuf_nodesale_proto_msgTypes[2]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *Tier) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*Tier) ProtoMessage() {}
-
-func (x *Tier) ProtoReflect() protoreflect.Message {
-	mi := &file_modules_nodesale_protobuf_nodesale_proto_msgTypes[2]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use Tier.ProtoReflect.Descriptor instead.
-func (*Tier) Descriptor() ([]byte, []int) {
-	return file_modules_nodesale_protobuf_nodesale_proto_rawDescGZIP(), []int{2}
-}
-
-func (x *Tier) GetPriceSat() uint32 {
-	if x != nil {
-		return x.PriceSat
-	}
-	return 0
-}
-
-func (x *Tier) GetLimit() uint32 {
-	if x != nil {
-		return x.Limit
-	}
-	return 0
-}
-
-func (x *Tier) GetMaxPerAddress() uint32 {
-	if x != nil {
-		return x.MaxPerAddress
-	}
-	return 0
-}
-
-type ActionPurchase struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Payload         *PurchasePayload `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
-	SellerSignature string           `protobuf:"bytes,2,opt,name=sellerSignature,proto3" json:"sellerSignature,omitempty"`
-}
-
-func (x *ActionPurchase) Reset() {
-	*x = ActionPurchase{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_modules_nodesale_protobuf_nodesale_proto_msgTypes[3]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *ActionPurchase) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*ActionPurchase) ProtoMessage() {}
-
-func (x *ActionPurchase) ProtoReflect() protoreflect.Message {
-	mi := &file_modules_nodesale_protobuf_nodesale_proto_msgTypes[3]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use ActionPurchase.ProtoReflect.Descriptor instead.
-func (*ActionPurchase) Descriptor() ([]byte, []int) {
-	return file_modules_nodesale_protobuf_nodesale_proto_rawDescGZIP(), []int{3}
-}
-
-func (x *ActionPurchase) GetPayload() *PurchasePayload {
-	if x != nil {
-		return x.Payload
-	}
-	return nil
-}
-
-func (x *ActionPurchase) GetSellerSignature() string {
-	if x != nil {
-		return x.SellerSignature
-	}
-	return ""
-}
-
-type PurchasePayload struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	DeployID       *ActionID `protobuf:"bytes,1,opt,name=deployID,proto3" json:"deployID,omitempty"`
-	BuyerPublicKey string    `protobuf:"bytes,2,opt,name=buyerPublicKey,proto3" json:"buyerPublicKey,omitempty"`
-	NodeIDs        []uint32  `protobuf:"varint,3,rep,packed,name=nodeIDs,proto3" json:"nodeIDs,omitempty"`
-	TotalAmountSat int64     `protobuf:"varint,4,opt,name=totalAmountSat,proto3" json:"totalAmountSat,omitempty"`
-	TimeOutBlock   uint64    `protobuf:"varint,5,opt,name=timeOutBlock,proto3" json:"timeOutBlock,omitempty"`
-}
-
-func (x *PurchasePayload) Reset() {
-	*x = PurchasePayload{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_modules_nodesale_protobuf_nodesale_proto_msgTypes[4]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *PurchasePayload) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*PurchasePayload) ProtoMessage() {}
-
-func (x *PurchasePayload) ProtoReflect() protoreflect.Message {
-	mi := &file_modules_nodesale_protobuf_nodesale_proto_msgTypes[4]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use PurchasePayload.ProtoReflect.Descriptor instead.
-func (*PurchasePayload) Descriptor() ([]byte, []int) {
-	return file_modules_nodesale_protobuf_nodesale_proto_rawDescGZIP(), []int{4}
-}
-
-func (x *PurchasePayload) GetDeployID() *ActionID {
-	if x != nil {
-		return x.DeployID
-	}
-	return nil
-}
-
-func (x *PurchasePayload) GetBuyerPublicKey() string {
-	if x != nil {
-		return x.BuyerPublicKey
-	}
-	return ""
-}
-
-func (x *PurchasePayload) GetNodeIDs() []uint32 {
-	if x != nil {
-		return x.NodeIDs
-	}
-	return nil
-}
-
-func (x *PurchasePayload) GetTotalAmountSat() int64 {
-	if x != nil {
-		return x.TotalAmountSat
-	}
-	return 0
-}
-
-func (x *PurchasePayload) GetTimeOutBlock() uint64 {
-	if x != nil {
-		return x.TimeOutBlock
-	}
-	return 0
-}
-
-type ActionID struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Block   uint64 `protobuf:"varint,1,opt,name=block,proto3" json:"block,omitempty"`
-	TxIndex uint32 `protobuf:"varint,2,opt,name=txIndex,proto3" json:"txIndex,omitempty"`
-}
-
-func (x *ActionID) Reset() {
-	*x = ActionID{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_modules_nodesale_protobuf_nodesale_proto_msgTypes[5]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *ActionID) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*ActionID) ProtoMessage() {}
-
-func (x *ActionID) ProtoReflect() protoreflect.Message {
-	mi := &file_modules_nodesale_protobuf_nodesale_proto_msgTypes[5]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use ActionID.ProtoReflect.Descriptor instead.
-func (*ActionID) Descriptor() ([]byte, []int) {
-	return file_modules_nodesale_protobuf_nodesale_proto_rawDescGZIP(), []int{5}
-}
-
-func (x *ActionID) GetBlock() uint64 {
-	if x != nil {
-		return x.Block
-	}
-	return 0
-}
-
-func (x *ActionID) GetTxIndex() uint32 {
-	if x != nil {
-		return x.TxIndex
-	}
-	return 0
-}
-
-type ActionDelegate struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	DelegateePublicKey string    `protobuf:"bytes,1,opt,name=delegateePublicKey,proto3" json:"delegateePublicKey,omitempty"`
-	NodeIDs            []uint32  `protobuf:"varint,2,rep,packed,name=nodeIDs,proto3" json:"nodeIDs,omitempty"`
-	DeployID           *ActionID `protobuf:"bytes,3,opt,name=deployID,proto3" json:"deployID,omitempty"`
-}
-
-func (x *ActionDelegate) Reset() {
-	*x = ActionDelegate{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_modules_nodesale_protobuf_nodesale_proto_msgTypes[6]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *ActionDelegate) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*ActionDelegate) ProtoMessage() {}
-
-func (x *ActionDelegate) ProtoReflect() protoreflect.Message {
-	mi := &file_modules_nodesale_protobuf_nodesale_proto_msgTypes[6]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use ActionDelegate.ProtoReflect.Descriptor instead.
-func (*ActionDelegate) Descriptor() ([]byte, []int) {
-	return file_modules_nodesale_protobuf_nodesale_proto_rawDescGZIP(), []int{6}
-}
-
-func (x *ActionDelegate) GetDelegateePublicKey() string {
-	if x != nil {
-		return x.DelegateePublicKey
-	}
-	return ""
-}
-
-func (x *ActionDelegate) GetNodeIDs() []uint32 {
-	if x != nil {
-		return x.NodeIDs
-	}
-	return nil
-}
-
-func (x *ActionDelegate) GetDeployID() *ActionID {
-	if x != nil {
-		return x.DeployID
-	}
-	return nil
-}
-
-var File_modules_nodesale_protobuf_nodesale_proto protoreflect.FileDescriptor
-
-var file_modules_nodesale_protobuf_nodesale_proto_rawDesc = []byte{
-	0x0a, 0x28, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x73, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x61,
-	0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x6e, 0x6f, 0x64, 0x65,
-	0x73, 0x61, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x08, 0x6e, 0x6f, 0x64, 0x65,
-	0x73, 0x61, 0x6c, 0x65, 0x22, 0x89, 0x02, 0x0a, 0x0d, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x61, 0x6c,
-	0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x28, 0x0a, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x10, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x61, 0x6c,
-	0x65, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-	0x12, 0x33, 0x0a, 0x06, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b,
-	0x32, 0x16, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x61, 0x6c, 0x65, 0x2e, 0x41, 0x63, 0x74, 0x69,
-	0x6f, 0x6e, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x48, 0x00, 0x52, 0x06, 0x64, 0x65, 0x70, 0x6c,
-	0x6f, 0x79, 0x88, 0x01, 0x01, 0x12, 0x39, 0x0a, 0x08, 0x70, 0x75, 0x72, 0x63, 0x68, 0x61, 0x73,
-	0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x61,
-	0x6c, 0x65, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x75, 0x72, 0x63, 0x68, 0x61, 0x73,
-	0x65, 0x48, 0x01, 0x52, 0x08, 0x70, 0x75, 0x72, 0x63, 0x68, 0x61, 0x73, 0x65, 0x88, 0x01, 0x01,
-	0x12, 0x39, 0x0a, 0x08, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01,
-	0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x61, 0x6c, 0x65, 0x2e, 0x41, 0x63,
-	0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x48, 0x02, 0x52, 0x08,
-	0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x88, 0x01, 0x01, 0x42, 0x09, 0x0a, 0x07, 0x5f,
-	0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x42, 0x0b, 0x0a, 0x09, 0x5f, 0x70, 0x75, 0x72, 0x63, 0x68,
-	0x61, 0x73, 0x65, 0x42, 0x0b, 0x0a, 0x09, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65,
-	0x22, 0xa6, 0x02, 0x0a, 0x0c, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x70, 0x6c, 0x6f,
-	0x79, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x73, 0x74, 0x61, 0x72, 0x74, 0x73, 0x41,
-	0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08, 0x73, 0x74, 0x61, 0x72, 0x74, 0x73, 0x41,
-	0x74, 0x12, 0x16, 0x0a, 0x06, 0x65, 0x6e, 0x64, 0x73, 0x41, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28,
-	0x0d, 0x52, 0x06, 0x65, 0x6e, 0x64, 0x73, 0x41, 0x74, 0x12, 0x24, 0x0a, 0x05, 0x74, 0x69, 0x65,
-	0x72, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x73,
-	0x61, 0x6c, 0x65, 0x2e, 0x54, 0x69, 0x65, 0x72, 0x52, 0x05, 0x74, 0x69, 0x65, 0x72, 0x73, 0x12,
-	0x28, 0x0a, 0x0f, 0x73, 0x65, 0x6c, 0x6c, 0x65, 0x72, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b,
-	0x65, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x73, 0x65, 0x6c, 0x6c, 0x65, 0x72,
-	0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x12, 0x24, 0x0a, 0x0d, 0x6d, 0x61, 0x78,
-	0x50, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d,
-	0x52, 0x0d, 0x6d, 0x61, 0x78, 0x50, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12,
-	0x34, 0x0a, 0x15, 0x6d, 0x61, 0x78, 0x44, 0x69, 0x73, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x50, 0x65,
-	0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x15,
-	0x6d, 0x61, 0x78, 0x44, 0x69, 0x73, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x50, 0x65, 0x72, 0x63, 0x65,
-	0x6e, 0x74, 0x61, 0x67, 0x65, 0x12, 0x22, 0x0a, 0x0c, 0x73, 0x65, 0x6c, 0x6c, 0x65, 0x72, 0x57,
-	0x61, 0x6c, 0x6c, 0x65, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x73, 0x65, 0x6c,
-	0x6c, 0x65, 0x72, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x22, 0x5e, 0x0a, 0x04, 0x54, 0x69, 0x65,
-	0x72, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x72, 0x69, 0x63, 0x65, 0x53, 0x61, 0x74, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x0d, 0x52, 0x08, 0x70, 0x72, 0x69, 0x63, 0x65, 0x53, 0x61, 0x74, 0x12, 0x14, 0x0a,
-	0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x6c, 0x69,
-	0x6d, 0x69, 0x74, 0x12, 0x24, 0x0a, 0x0d, 0x6d, 0x61, 0x78, 0x50, 0x65, 0x72, 0x41, 0x64, 0x64,
-	0x72, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0d, 0x6d, 0x61, 0x78, 0x50,
-	0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x6f, 0x0a, 0x0e, 0x41, 0x63, 0x74,
-	0x69, 0x6f, 0x6e, 0x50, 0x75, 0x72, 0x63, 0x68, 0x61, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x07, 0x70,
-	0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x6e,
-	0x6f, 0x64, 0x65, 0x73, 0x61, 0x6c, 0x65, 0x2e, 0x50, 0x75, 0x72, 0x63, 0x68, 0x61, 0x73, 0x65,
-	0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x52, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64,
-	0x12, 0x28, 0x0a, 0x0f, 0x73, 0x65, 0x6c, 0x6c, 0x65, 0x72, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74,
-	0x75, 0x72, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x73, 0x65, 0x6c, 0x6c, 0x65,
-	0x72, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0xcf, 0x01, 0x0a, 0x0f, 0x50,
-	0x75, 0x72, 0x63, 0x68, 0x61, 0x73, 0x65, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x2e,
-	0x0a, 0x08, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
-	0x32, 0x12, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x61, 0x6c, 0x65, 0x2e, 0x41, 0x63, 0x74, 0x69,
-	0x6f, 0x6e, 0x49, 0x44, 0x52, 0x08, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x49, 0x44, 0x12, 0x26,
-	0x0a, 0x0e, 0x62, 0x75, 0x79, 0x65, 0x72, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x62, 0x75, 0x79, 0x65, 0x72, 0x50, 0x75, 0x62,
-	0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44,
-	0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0d, 0x52, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x73,
-	0x12, 0x26, 0x0a, 0x0e, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x53,
-	0x61, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x41,
-	0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x53, 0x61, 0x74, 0x12, 0x22, 0x0a, 0x0c, 0x74, 0x69, 0x6d, 0x65,
-	0x4f, 0x75, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0c,
-	0x74, 0x69, 0x6d, 0x65, 0x4f, 0x75, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x3a, 0x0a, 0x08,
-	0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x14, 0x0a, 0x05, 0x62, 0x6c, 0x6f, 0x63,
-	0x6b, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x12, 0x18,
-	0x0a, 0x07, 0x74, 0x78, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52,
-	0x07, 0x74, 0x78, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x8a, 0x01, 0x0a, 0x0e, 0x41, 0x63, 0x74,
-	0x69, 0x6f, 0x6e, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x12, 0x2e, 0x0a, 0x12, 0x64,
-	0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x65, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65,
-	0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74,
-	0x65, 0x65, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x6e,
-	0x6f, 0x64, 0x65, 0x49, 0x44, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0d, 0x52, 0x07, 0x6e, 0x6f,
-	0x64, 0x65, 0x49, 0x44, 0x73, 0x12, 0x2e, 0x0a, 0x08, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x49,
-	0x44, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x61,
-	0x6c, 0x65, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x52, 0x08, 0x64, 0x65, 0x70,
-	0x6c, 0x6f, 0x79, 0x49, 0x44, 0x2a, 0x45, 0x0a, 0x06, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12,
-	0x11, 0x0a, 0x0d, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x44, 0x45, 0x50, 0x4c, 0x4f, 0x59,
-	0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x41, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x55, 0x52,
-	0x43, 0x48, 0x41, 0x53, 0x45, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x41, 0x43, 0x54, 0x49, 0x4f,
-	0x4e, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x47, 0x41, 0x54, 0x45, 0x10, 0x02, 0x42, 0x43, 0x5a, 0x41,
-	0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x61, 0x7a, 0x65, 0x2d,
-	0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x2f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x65, 0x72, 0x2d,
-	0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x2f, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x73, 0x2f,
-	0x6e, 0x6f, 0x64, 0x65, 0x73, 0x61, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
-	0x66, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
-}
-
-var (
-	file_modules_nodesale_protobuf_nodesale_proto_rawDescOnce sync.Once
-	file_modules_nodesale_protobuf_nodesale_proto_rawDescData = file_modules_nodesale_protobuf_nodesale_proto_rawDesc
-)
-
-func file_modules_nodesale_protobuf_nodesale_proto_rawDescGZIP() []byte {
-	file_modules_nodesale_protobuf_nodesale_proto_rawDescOnce.Do(func() {
-		file_modules_nodesale_protobuf_nodesale_proto_rawDescData = protoimpl.X.CompressGZIP(file_modules_nodesale_protobuf_nodesale_proto_rawDescData)
-	})
-	return file_modules_nodesale_protobuf_nodesale_proto_rawDescData
-}
-
-var file_modules_nodesale_protobuf_nodesale_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
-var file_modules_nodesale_protobuf_nodesale_proto_msgTypes = make([]protoimpl.MessageInfo, 7)
-var file_modules_nodesale_protobuf_nodesale_proto_goTypes = []interface{}{
-	(Action)(0),             // 0: nodesale.Action
-	(*NodeSaleEvent)(nil),   // 1: nodesale.NodeSaleEvent
-	(*ActionDeploy)(nil),    // 2: nodesale.ActionDeploy
-	(*Tier)(nil),            // 3: nodesale.Tier
-	(*ActionPurchase)(nil),  // 4: nodesale.ActionPurchase
-	(*PurchasePayload)(nil), // 5: nodesale.PurchasePayload
-	(*ActionID)(nil),        // 6: nodesale.ActionID
-	(*ActionDelegate)(nil),  // 7: nodesale.ActionDelegate
-}
-var file_modules_nodesale_protobuf_nodesale_proto_depIdxs = []int32{
-	0, // 0: nodesale.NodeSaleEvent.action:type_name -> nodesale.Action
-	2, // 1: nodesale.NodeSaleEvent.deploy:type_name -> nodesale.ActionDeploy
-	4, // 2: nodesale.NodeSaleEvent.purchase:type_name -> nodesale.ActionPurchase
-	7, // 3: nodesale.NodeSaleEvent.delegate:type_name -> nodesale.ActionDelegate
-	3, // 4: nodesale.ActionDeploy.tiers:type_name -> nodesale.Tier
-	5, // 5: nodesale.ActionPurchase.payload:type_name -> nodesale.PurchasePayload
-	6, // 6: nodesale.PurchasePayload.deployID:type_name -> nodesale.ActionID
-	6, // 7: nodesale.ActionDelegate.deployID:type_name -> nodesale.ActionID
-	8, // [8:8] is the sub-list for method output_type
-	8, // [8:8] is the sub-list for method input_type
-	8, // [8:8] is the sub-list for extension type_name
-	8, // [8:8] is the sub-list for extension extendee
-	0, // [0:8] is the sub-list for field type_name
-}
-
-func init() { file_modules_nodesale_protobuf_nodesale_proto_init() }
-func file_modules_nodesale_protobuf_nodesale_proto_init() {
-	if File_modules_nodesale_protobuf_nodesale_proto != nil {
-		return
-	}
-	if !protoimpl.UnsafeEnabled {
-		file_modules_nodesale_protobuf_nodesale_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*NodeSaleEvent); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_modules_nodesale_protobuf_nodesale_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ActionDeploy); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_modules_nodesale_protobuf_nodesale_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Tier); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_modules_nodesale_protobuf_nodesale_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ActionPurchase); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_modules_nodesale_protobuf_nodesale_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*PurchasePayload); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_modules_nodesale_protobuf_nodesale_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ActionID); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_modules_nodesale_protobuf_nodesale_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ActionDelegate); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-	}
-	file_modules_nodesale_protobuf_nodesale_proto_msgTypes[0].OneofWrappers = []interface{}{}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_modules_nodesale_protobuf_nodesale_proto_rawDesc,
-			NumEnums:      1,
-			NumMessages:   7,
-			NumExtensions: 0,
-			NumServices:   0,
-		},
-		GoTypes:           file_modules_nodesale_protobuf_nodesale_proto_goTypes,
-		DependencyIndexes: file_modules_nodesale_protobuf_nodesale_proto_depIdxs,
-		EnumInfos:         file_modules_nodesale_protobuf_nodesale_proto_enumTypes,
-		MessageInfos:      file_modules_nodesale_protobuf_nodesale_proto_msgTypes,
-	}.Build()
-	File_modules_nodesale_protobuf_nodesale_proto = out.File
-	file_modules_nodesale_protobuf_nodesale_proto_rawDesc = nil
-	file_modules_nodesale_protobuf_nodesale_proto_goTypes = nil
-	file_modules_nodesale_protobuf_nodesale_proto_depIdxs = nil
-}

modules/nodesale/protobuf/nodesale.proto

@@ -1,60 +0,0 @@
-syntax = "proto3";
-
-// protoc modules/nodesale/protobuf/nodesale.proto --go_out=. --go_opt=module=github.com/gaze-network/indexer-network
-
-package nodesale;
-option go_package = "github.com/gaze-network/indexer-network/modules/nodesale/protobuf";
-
-enum Action {
-  ACTION_DEPLOY = 0;
-  ACTION_PURCHASE = 1;
-  ACTION_DELEGATE = 2;
-}
-
-message NodeSaleEvent {
-	Action action = 1;
-	optional ActionDeploy deploy = 2;
-	optional ActionPurchase purchase = 3;
-	optional ActionDelegate delegate = 4;
-}
-
-message ActionDeploy {
-	string name = 1;
-	uint32 startsAt = 2;
-	uint32 endsAt = 3;
-	repeated Tier tiers = 4;
-	string sellerPublicKey = 5;
-	uint32 maxPerAddress = 6;
-	uint32 maxDiscountPercentage = 7;
-	string sellerWallet = 8;
-}
-
-message Tier {
-	uint32 priceSat = 1;
-	uint32 limit = 2;
-	uint32 maxPerAddress = 3;
-}
-
-message ActionPurchase {
-	PurchasePayload payload = 1;
-	string sellerSignature = 2;
-}
-
-message PurchasePayload {
-	ActionID deployID = 1;
-	string buyerPublicKey = 2;
-	repeated uint32 nodeIDs = 3;
-	int64 totalAmountSat = 4;
-	uint64 timeOutBlock = 5;
-}
-
-message ActionID {
-	uint64 block = 1;
-	uint32 txIndex = 2;
-}
-
-message ActionDelegate {
-	string delegateePublicKey = 1;
-	repeated uint32 nodeIDs = 2;
-	ActionID deployID = 3;
-}

modules/nodesale/pubkeyaddr.go

@@ -1,12 +0,0 @@
-package nodesale
-
-import (
-	"github.com/btcsuite/btcd/btcec/v2"
-	"github.com/btcsuite/btcd/btcutil"
-)
-
-func (p *Processor) PubkeyToPkHashAddress(pubKey *btcec.PublicKey) btcutil.Address {
-	addrPubKey, _ := btcutil.NewAddressPubKey(pubKey.SerializeCompressed(), p.Network.ChainParams())
-	addrPubKeyHash := addrPubKey.AddressPubKeyHash()
-	return addrPubKeyHash
-}

modules/nodesale/purchase.go

@@ -1,87 +0,0 @@
-package nodesale
-
-import (
-	"context"
-
-	"github.com/cockroachdb/errors"
-	"github.com/gaze-network/indexer-network/core/types"
-	"github.com/gaze-network/indexer-network/modules/nodesale/datagateway"
-	"github.com/gaze-network/indexer-network/modules/nodesale/internal/entity"
-	purchasevalidator "github.com/gaze-network/indexer-network/modules/nodesale/internal/validator/purchase"
-)
-
-func (p *Processor) ProcessPurchase(ctx context.Context, qtx datagateway.NodeSaleDataGatewayWithTx, block *types.Block, event NodeSaleEvent) error {
-	purchase := event.EventMessage.Purchase
-	payload := purchase.Payload
-
-	validator := purchasevalidator.New()
-
-	validator.EqualXonlyPublicKey(payload.BuyerPublicKey, event.TxPubkey)
-
-	_, deploy, err := validator.NodeSaleExists(ctx, qtx, payload)
-	if err != nil {
-		return errors.Wrap(err, "cannot query. Something wrong.")
-	}
-
-	validator.ValidTimestamp(deploy, block.Header.Timestamp)
-	validator.WithinTimeoutBlock(payload.TimeOutBlock, uint64(event.Transaction.BlockHeight))
-
-	validator.VerifySignature(purchase, deploy)
-
-	_, tierMap := validator.ValidTiers(payload, deploy)
-
-	tiers := tierMap.Tiers
-	buyingTiersCount := tierMap.BuyingTiersCount
-	nodeIdToTier := tierMap.NodeIdToTier
-
-	_, err = validator.ValidUnpurchasedNodes(ctx, qtx, payload)
-	if err != nil {
-		return errors.Wrap(err, "cannot query. Something wrong.")
-	}
-
-	_, meta := validator.ValidPaidAmount(payload, deploy, event.InputValue, tiers, buyingTiersCount, p.Network.ChainParams())
-
-	_, err = validator.WithinLimit(ctx, qtx, payload, deploy, tiers, buyingTiersCount)
-	if err != nil {
-		return errors.Wrap(err, "cannot query. Something wrong.")
-	}
-
-	err = qtx.CreateEvent(ctx, entity.NodeSaleEvent{
-		TxHash:         event.Transaction.TxHash.String(),
-		TxIndex:        int32(event.Transaction.Index),
-		Action:         int32(event.EventMessage.Action),
-		RawMessage:     event.RawData,
-		ParsedMessage:  event.EventJson,
-		BlockTimestamp: block.Header.Timestamp,
-		BlockHash:      event.Transaction.BlockHash.String(),
-		BlockHeight:    event.Transaction.BlockHeight,
-		Valid:          validator.Valid,
-		WalletAddress:  p.PubkeyToPkHashAddress(event.TxPubkey).EncodeAddress(),
-		Metadata:       meta,
-		Reason:         validator.Reason,
-	})
-	if err != nil {
-		return errors.Wrap(err, "Failed to insert event")
-	}
-
-	if validator.Valid {
-		// add to node
-		for _, nodeId := range payload.NodeIDs {
-			err := qtx.CreateNode(ctx, entity.Node{
-				SaleBlock:      deploy.BlockHeight,
-				SaleTxIndex:    deploy.TxIndex,
-				NodeID:         nodeId,
-				TierIndex:      nodeIdToTier[nodeId],
-				DelegatedTo:    "",
-				OwnerPublicKey: payload.BuyerPublicKey,
-				PurchaseTxHash: event.Transaction.TxHash.String(),
-				DelegateTxHash: "",
-			})
-			if err != nil {
-				return errors.Wrap(err, "Failed to insert node")
-			}
-		}
-	}
-
-	return nil
-}

modules/nodesale/purchase_test.go

@@ -1,902 +0,0 @@
-package nodesale
-
-import (
-	"context"
-	"encoding/hex"
-	"testing"
-	"time"
-
-	"github.com/btcsuite/btcd/btcec/v2"
-	"github.com/btcsuite/btcd/chaincfg/chainhash"
-	"github.com/decred/dcrd/dcrec/secp256k1/v4/ecdsa"
-	"github.com/gaze-network/indexer-network/common"
-	"github.com/gaze-network/indexer-network/modules/nodesale/datagateway"
-	"github.com/gaze-network/indexer-network/modules/nodesale/datagateway/mocks"
-	"github.com/gaze-network/indexer-network/modules/nodesale/internal/entity"
-	"github.com/gaze-network/indexer-network/modules/nodesale/internal/validator"
-	"github.com/gaze-network/indexer-network/modules/nodesale/internal/validator/purchase"
-	"github.com/gaze-network/indexer-network/modules/nodesale/protobuf"
-	"github.com/samber/lo"
-	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/require"
-	"google.golang.org/protobuf/encoding/protojson"
-	"google.golang.org/protobuf/proto"
-)
-
-func TestInvalidPurchase(t *testing.T) {
-	ctx := context.Background()
-	mockDgTx := mocks.NewNodeSaleDataGatewayWithTx(t)
-	p := NewProcessor(mockDgTx, nil, common.NetworkMainnet, nil, 0)
-
-	buyerPrivateKey, err := btcec.NewPrivateKey()
-	require.NoError(t, err)
-	buyerPubkeyHex := hex.EncodeToString(buyerPrivateKey.PubKey().SerializeCompressed())
-
-	message := &protobuf.NodeSaleEvent{
-		Action: protobuf.Action_ACTION_PURCHASE,
-		Purchase: &protobuf.ActionPurchase{
-			Payload: &protobuf.PurchasePayload{
-				DeployID: &protobuf.ActionID{
-					Block:   111,
-					TxIndex: 1,
-				},
-				NodeIDs:        []uint32{1, 2},
-				BuyerPublicKey: buyerPubkeyHex,
-				TotalAmountSat: 500,
-				TimeOutBlock:   uint64(testBlockHeight) + 5,
-			},
-		},
-	}
-
-	event, block := assembleTestEvent(buyerPrivateKey, "030303030303", "030303030303", 0, 0, message)
-
-	mockDgTx.EXPECT().GetNodeSale(mock.Anything, mock.Anything).Return(nil, nil)
-
-	mockDgTx.EXPECT().CreateEvent(mock.Anything, mock.MatchedBy(func(event entity.NodeSaleEvent) bool {
-		return event.Valid == false
-	})).Return(nil)
-
-	err = p.ProcessPurchase(ctx, mockDgTx, block, event)
-	require.NoError(t, err)
-
-	mockDgTx.AssertNotCalled(t, "CreateNode")
-}
-
-func TestInvalidBuyerKey(t *testing.T) {
-	ctx := context.Background()
-	mockDgTx := mocks.NewNodeSaleDataGatewayWithTx(t)
-	p := NewProcessor(mockDgTx, nil, common.NetworkMainnet, nil, 0)
-
-	strangerPrivateKey, _ := btcec.NewPrivateKey()
-	strangerPrivateKeyHex := hex.EncodeToString(strangerPrivateKey.PubKey().SerializeCompressed())
-
-	buyerPrivateKey, _ := btcec.NewPrivateKey()
-
-	message := &protobuf.NodeSaleEvent{
-		Action: protobuf.Action_ACTION_PURCHASE,
-		Purchase: &protobuf.ActionPurchase{
-			Payload: &protobuf.PurchasePayload{
-				DeployID: &protobuf.ActionID{
-					Block:   100,
-					TxIndex: 1,
-				},
-				NodeIDs:        []uint32{1, 2},
-				BuyerPublicKey: strangerPrivateKeyHex,
-				TotalAmountSat: 200,
-				TimeOutBlock:   uint64(testBlockHeight) + 5,
-			},
-		},
-	}
-
-	event, block := assembleTestEvent(buyerPrivateKey, "0707070707", "0707070707", 0, 0, message)
-	block.Header.Timestamp = time.Now().UTC()
-
-	mockDgTx.EXPECT().CreateEvent(mock.Anything, mock.MatchedBy(func(event entity.NodeSaleEvent) bool {
-		return event.Valid == false && event.Reason == validator.INVALID_PUBKEY
-	})).Return(nil)
-
-	err := p.ProcessPurchase(ctx, mockDgTx, block, event)
-	require.NoError(t, err)
-
-	mockDgTx.AssertNotCalled(t, "CreateNode")
-}
-
-func TestInvalidTimestamp(t *testing.T) {
-	ctx := context.Background()
-	mockDgTx := mocks.NewNodeSaleDataGatewayWithTx(t)
-	p := NewProcessor(mockDgTx, nil, common.NetworkMainnet, nil, 0)
-
-	sellerPrivateKey, err := btcec.NewPrivateKey()
-	require.NoError(t, err)
-
-	sellerPubkeyHex := hex.EncodeToString(sellerPrivateKey.PubKey().SerializeCompressed())
-	sellerWallet := p.PubkeyToPkHashAddress(sellerPrivateKey.PubKey())
-
-	startAt := time.Now().Add(time.Hour * -1)
-	endAt := time.Now().Add(time.Hour * 1)
-
-	tiers := lo.Map([]*protobuf.Tier{
-		{
-			PriceSat:      100,
-			Limit:         5,
-			MaxPerAddress: 100,
-		},
-		{
-			PriceSat:      200,
-			Limit:         5,
-			MaxPerAddress: 100,
-		},
-	}, func(tier *protobuf.Tier, _ int) []byte {
-		tierJson, err := protojson.Marshal(tier)
-		require.NoError(t, err)
-		return tierJson
-	})
-	mockDgTx.EXPECT().GetNodeSale(mock.Anything, datagateway.GetNodeSaleParams{
-		BlockHeight: 100,
-		TxIndex:     1,
-	}).Return([]entity.NodeSale{
-		{
-			BlockHeight:           100,
-			TxIndex:               1,
-			Name:                  t.Name(),
-			StartsAt:              startAt,
-			EndsAt:                endAt,
-			Tiers:                 tiers,
-			SellerPublicKey:       sellerPubkeyHex,
-			MaxPerAddress:         100,
-			DeployTxHash:          "040404040404",
-			MaxDiscountPercentage: 50,
-			SellerWallet:          sellerWallet.EncodeAddress(),
-		},
-	}, nil)
-
-	buyerPrivateKey, _ := btcec.NewPrivateKey()
-	buyerPubkeyHex := hex.EncodeToString(buyerPrivateKey.PubKey().SerializeCompressed())
-
-	message := &protobuf.NodeSaleEvent{
-		Action: protobuf.Action_ACTION_PURCHASE,
-		Purchase: &protobuf.ActionPurchase{
-			Payload: &protobuf.PurchasePayload{
-				DeployID: &protobuf.ActionID{
-					Block:   100,
-					TxIndex: 1,
-				},
-				NodeIDs:        []uint32{1, 2},
-				BuyerPublicKey: buyerPubkeyHex,
-				TotalAmountSat: 200,
-				TimeOutBlock:   uint64(testBlockHeight) + 5,
-			},
-		},
-	}
-
-	event, block := assembleTestEvent(buyerPrivateKey, "050505050505", "050505050505", 0, 0, message)
-
-	block.Header.Timestamp = time.Now().UTC().Add(time.Hour * 2)
-
-	mockDgTx.EXPECT().CreateEvent(mock.Anything, mock.MatchedBy(func(event entity.NodeSaleEvent) bool {
-		return event.Valid == false && event.Reason == purchase.PURCHASE_TIMEOUT
-	})).Return(nil)
-
-	err = p.ProcessPurchase(ctx, mockDgTx, block, event)
-	require.NoError(t, err)
-
-	mockDgTx.AssertNotCalled(t, "CreateNode")
-}
-
-func TestTimeOut(t *testing.T) {
-	ctx := context.Background()
-	mockDgTx := mocks.NewNodeSaleDataGatewayWithTx(t)
-	p := NewProcessor(mockDgTx, nil, common.NetworkMainnet, nil, 0)
-
-	sellerPrivateKey, _ := btcec.NewPrivateKey()
-	sellerPubkeyHex := hex.EncodeToString(sellerPrivateKey.PubKey().SerializeCompressed())
-	sellerWallet := p.PubkeyToPkHashAddress(sellerPrivateKey.PubKey())
-
-	startAt := time.Now().Add(time.Hour * -1)
-	endAt := time.Now().Add(time.Hour * 1)
-
-	tiers := lo.Map([]*protobuf.Tier{
-		{
-			PriceSat:      100,
-			Limit:         5,
-			MaxPerAddress: 100,
-		},
-		{
-			PriceSat:      200,
-			Limit:         5,
-			MaxPerAddress: 100,
-		},
-	}, func(tier *protobuf.Tier, _ int) []byte {
-		tierJson, err := protojson.Marshal(tier)
-		require.NoError(t, err)
-		return tierJson
-	})
-
-	mockDgTx.EXPECT().GetNodeSale(mock.Anything, datagateway.GetNodeSaleParams{
-		BlockHeight: 100,
-		TxIndex:     1,
-	}).Return([]entity.NodeSale{
-		{
-			BlockHeight:           100,
-			TxIndex:               1,
-			Name:                  t.Name(),
-			StartsAt:              startAt,
-			EndsAt:                endAt,
-			Tiers:                 tiers,
-			SellerPublicKey:       sellerPubkeyHex,
-			MaxPerAddress:         100,
-			DeployTxHash:          "040404040404",
-			MaxDiscountPercentage: 50,
-			SellerWallet:          sellerWallet.EncodeAddress(),
-		},
-	}, nil)
-
-	buyerPrivateKey, _ := btcec.NewPrivateKey()
-	buyerPubkeyHex := hex.EncodeToString(buyerPrivateKey.PubKey().SerializeCompressed())
-
-	message := &protobuf.NodeSaleEvent{
-		Action: protobuf.Action_ACTION_PURCHASE,
-		Purchase: &protobuf.ActionPurchase{
-			Payload: &protobuf.PurchasePayload{
-				DeployID: &protobuf.ActionID{
-					Block:   100,
-					TxIndex: 1,
-				},
-				NodeIDs:        []uint32{1, 2},
-				BuyerPublicKey: buyerPubkeyHex,
-				TimeOutBlock:   uint64(testBlockHeight) - 5,
-				TotalAmountSat: 200,
-			},
-		},
-	}
-
-	event, block := assembleTestEvent(buyerPrivateKey, "090909090909", "090909090909", 0, 0, message)
-
-	mockDgTx.EXPECT().CreateEvent(mock.Anything, mock.MatchedBy(func(event entity.NodeSaleEvent) bool {
-		return event.Valid == false && event.Reason == purchase.BLOCK_HEIGHT_TIMEOUT
-	})).Return(nil)
-
-	err := p.ProcessPurchase(ctx, mockDgTx, block, event)
-	require.NoError(t, err)
-
-	mockDgTx.AssertNotCalled(t, "CreateNode")
-}
-
-func TestSignatureInvalid(t *testing.T) {
-	ctx := context.Background()
-	mockDgTx := mocks.NewNodeSaleDataGatewayWithTx(t)
-	p := NewProcessor(mockDgTx, nil, common.NetworkMainnet, nil, 0)
-
-	sellerPrivateKey, _ := btcec.NewPrivateKey()
-	sellerPubkeyHex := hex.EncodeToString(sellerPrivateKey.PubKey().SerializeCompressed())
-	sellerWallet := p.PubkeyToPkHashAddress(sellerPrivateKey.PubKey())
-
-	startAt := time.Now().Add(time.Hour * -1)
-	endAt := time.Now().Add(time.Hour * 1)
-
-	tiers := lo.Map([]*protobuf.Tier{
-		{
-			PriceSat:      100,
-			Limit:         5,
-			MaxPerAddress: 100,
-		},
-		{
-			PriceSat:      200,
-			Limit:         5,
-			MaxPerAddress: 100,
-		},
-	}, func(tier *protobuf.Tier, _ int) []byte {
-		tierJson, err := protojson.Marshal(tier)
-		require.NoError(t, err)
-		return tierJson
-	})
-	mockDgTx.EXPECT().GetNodeSale(mock.Anything, datagateway.GetNodeSaleParams{
-		BlockHeight: 100,
-		TxIndex:     1,
-	}).Return([]entity.NodeSale{
-		{
-			BlockHeight:           100,
-			TxIndex:               1,
-			Name:                  t.Name(),
-			StartsAt:              startAt,
-			EndsAt:                endAt,
-			Tiers:                 tiers,
-			SellerPublicKey:       sellerPubkeyHex,
-			MaxPerAddress:         100,
-			DeployTxHash:          "040404040404",
-			MaxDiscountPercentage: 50,
-			SellerWallet:          sellerWallet.EncodeAddress(),
-		},
-	}, nil)
-
-	buyerPrivateKey, _ := btcec.NewPrivateKey()
-	buyerPubkeyHex := hex.EncodeToString(buyerPrivateKey.PubKey().SerializeCompressed())
-
-	payload := &protobuf.PurchasePayload{
-		DeployID: &protobuf.ActionID{
-			Block:   100,
-			TxIndex: 1,
-		},
-		NodeIDs:        []uint32{1, 2},
-		BuyerPublicKey: buyerPubkeyHex,
-		TimeOutBlock:   testBlockHeight + 5,
-	}
-
-	payloadBytes, _ := proto.Marshal(payload)
-	payloadHash := chainhash.DoubleHashB(payloadBytes)
-	signature := ecdsa.Sign(buyerPrivateKey, payloadHash[:])
-	signatureHex := hex.EncodeToString(signature.Serialize())
-
-	message := &protobuf.NodeSaleEvent{
-		Action: protobuf.Action_ACTION_PURCHASE,
-		Purchase: &protobuf.ActionPurchase{
-			Payload:         payload,
-			SellerSignature: signatureHex,
-		},
-	}
-
-	event, block := assembleTestEvent(buyerPrivateKey, "0B0B0B", "0B0B0B", 0, 0, message)
-
-	mockDgTx.EXPECT().CreateEvent(mock.Anything, mock.MatchedBy(func(event entity.NodeSaleEvent) bool {
-		return event.Valid == false && event.Reason == purchase.INVALID_SIGNATURE
-	})).Return(nil)
-
-	err := p.ProcessPurchase(ctx, mockDgTx, block, event)
-	require.NoError(t, err)
-
-	mockDgTx.AssertNotCalled(t, "CreateNode")
-}
-
-func TestValidPurchase(t *testing.T) {
-	ctx := context.Background()
-	mockDgTx := mocks.NewNodeSaleDataGatewayWithTx(t)
-	p := NewProcessor(mockDgTx, nil, common.NetworkMainnet, nil, 0)
-
-	sellerPrivateKey, _ := btcec.NewPrivateKey()
-	sellerPubkeyHex := hex.EncodeToString(sellerPrivateKey.PubKey().SerializeCompressed())
-	sellerWallet := p.PubkeyToPkHashAddress(sellerPrivateKey.PubKey())
-
-	startAt := time.Now().Add(time.Hour * -1)
-	endAt := time.Now().Add(time.Hour * 1)
-
-	tiers := lo.Map([]*protobuf.Tier{
-		{
-			PriceSat:      100,
-			Limit:         5,
-			MaxPerAddress: 100,
-		},
-		{
-			PriceSat:      200,
-			Limit:         4,
-			MaxPerAddress: 2,
-		},
-		{
-			PriceSat:      400,
-			Limit:         3,
-			MaxPerAddress: 100,
-		},
-	}, func(tier *protobuf.Tier, _ int) []byte {
-		tierJson, err := protojson.Marshal(tier)
-		require.NoError(t, err)
-		return tierJson
-	})
-
-	mockDgTx.EXPECT().GetNodeSale(mock.Anything, datagateway.GetNodeSaleParams{
-		BlockHeight: 100,
-		TxIndex:     1,
-	}).Return([]entity.NodeSale{
-		{
-			BlockHeight:           100,
-			TxIndex:               1,
-			Name:                  t.Name(),
-			StartsAt:              startAt,
-			EndsAt:                endAt,
-			Tiers:                 tiers,
-			SellerPublicKey:       sellerPubkeyHex,
-			MaxPerAddress:         100,
-			DeployTxHash:          "040404040404",
-			MaxDiscountPercentage: 50,
-			SellerWallet:          sellerWallet.EncodeAddress(),
-		},
-	}, nil)
-
-	mockDgTx.EXPECT().GetNodesByIds(mock.Anything, mock.Anything).Return(nil, nil)
-
-	mockDgTx.EXPECT().GetNodesByOwner(mock.Anything, mock.Anything).Return(nil, nil)
-
-	buyerPrivateKey, _ := btcec.NewPrivateKey()
-	buyerPubkeyHex := hex.EncodeToString(buyerPrivateKey.PubKey().SerializeCompressed())
-
-	payload := &protobuf.PurchasePayload{
-		DeployID: &protobuf.ActionID{
-			Block:   100,
-			TxIndex: 1,
-		},
-		BuyerPublicKey: buyerPubkeyHex,
-		TimeOutBlock:   uint64(testBlockHeight) + 5,
-		NodeIDs:        []uint32{0, 5, 6, 9},
-		TotalAmountSat: 500,
-	}
-
-	payloadBytes, _ := proto.Marshal(payload)
-	payloadHash := chainhash.DoubleHashB(payloadBytes)
-	signature := ecdsa.Sign(sellerPrivateKey, payloadHash[:])
-	signatureHex := hex.EncodeToString(signature.Serialize())
-
-	message := &protobuf.NodeSaleEvent{
-		Action: protobuf.Action_ACTION_PURCHASE,
-		Purchase: &protobuf.ActionPurchase{
-			Payload:         payload,
-			SellerSignature: signatureHex,
-		},
-	}
-
-	event, block := assembleTestEvent(buyerPrivateKey, "0D0D0D0D", "0D0D0D0D", 0, 0, message)
-	event.InputValue = 500
-
-	mockDgTx.EXPECT().CreateEvent(mock.Anything, mock.MatchedBy(func(event entity.NodeSaleEvent) bool {
-		return event.Valid == true && event.Reason == ""
-	})).Return(nil)
-
-	mockDgTx.EXPECT().CreateNode(mock.Anything, mock.MatchedBy(func(node entity.Node) bool {
-		return node.NodeID == 0 &&
-			node.TierIndex == 0 &&
-			node.OwnerPublicKey == buyerPubkeyHex &&
-			node.PurchaseTxHash == event.Transaction.TxHash.String() &&
-			node.SaleBlock == 100 &&
-			node.SaleTxIndex == 1
-	})).Return(nil)
-
-	mockDgTx.EXPECT().CreateNode(mock.Anything, mock.MatchedBy(func(node entity.Node) bool {
-		return node.NodeID == 5 &&
-			node.TierIndex == 1 &&
-			node.OwnerPublicKey == buyerPubkeyHex &&
-			node.PurchaseTxHash == event.Transaction.TxHash.String() &&
-			node.SaleBlock == 100 &&
-			node.SaleTxIndex == 1
-	})).Return(nil)
-
-	mockDgTx.EXPECT().CreateNode(mock.Anything, mock.MatchedBy(func(node entity.Node) bool {
-		return node.NodeID == 6 &&
-			node.TierIndex == 1 &&
-			node.OwnerPublicKey == buyerPubkeyHex &&
-			node.PurchaseTxHash == event.Transaction.TxHash.String() &&
-			node.SaleBlock == 100 &&
-			node.SaleTxIndex == 1
-	})).Return(nil)
-
-	mockDgTx.EXPECT().CreateNode(mock.Anything, mock.MatchedBy(func(node entity.Node) bool {
-		return node.NodeID == 9 &&
-			node.TierIndex == 2 &&
-			node.OwnerPublicKey == buyerPubkeyHex &&
-			node.PurchaseTxHash == event.Transaction.TxHash.String() &&
-			node.SaleBlock == 100 &&
-			node.SaleTxIndex == 1
-	})).Return(nil)
-
-	err := p.ProcessPurchase(ctx, mockDgTx, block, event)
-	require.NoError(t, err)
-}
-
-func TestMismatchPayment(t *testing.T) {
-	ctx := context.Background()
-	mockDgTx := mocks.NewNodeSaleDataGatewayWithTx(t)
-	p := NewProcessor(mockDgTx, nil, common.NetworkMainnet, nil, 0)
-
-	sellerPrivateKey, _ := btcec.NewPrivateKey()
-	sellerPubkeyHex := hex.EncodeToString(sellerPrivateKey.PubKey().SerializeCompressed())
-	sellerWallet := p.PubkeyToPkHashAddress(sellerPrivateKey.PubKey())
-
-	startAt := time.Now().Add(time.Hour * -1)
-	endAt := time.Now().Add(time.Hour * 1)
-
-	tiers := lo.Map([]*protobuf.Tier{
-		{
-			PriceSat:      100,
-			Limit:         5,
-			MaxPerAddress: 100,
-		},
-		{
-			PriceSat:      200,
-			Limit:         4,
-			MaxPerAddress: 2,
-		},
-		{
-			PriceSat:      400,
-			Limit:         3,
-			MaxPerAddress: 100,
-		},
-	}, func(tier *protobuf.Tier, _ int) []byte {
-		tierJson, err := protojson.Marshal(tier)
-		require.NoError(t, err)
-		return tierJson
-	})
-
-	mockDgTx.EXPECT().GetNodeSale(mock.Anything, datagateway.GetNodeSaleParams{
-		BlockHeight: 100,
-		TxIndex:     1,
-	}).Return([]entity.NodeSale{
-		{
-			BlockHeight:           100,
-			TxIndex:               1,
-			Name:                  t.Name(),
-			StartsAt:              startAt,
-			EndsAt:                endAt,
-			Tiers:                 tiers,
-			SellerPublicKey:       sellerPubkeyHex,
-			MaxPerAddress:         100,
-			DeployTxHash:          "040404040404",
-			MaxDiscountPercentage: 50,
-			SellerWallet:          sellerWallet.EncodeAddress(),
-		},
-	}, nil)
-
-	mockDgTx.EXPECT().GetNodesByIds(mock.Anything, mock.Anything).Return(nil, nil)
-
-	buyerPrivateKey, _ := btcec.NewPrivateKey()
-	buyerPubkeyHex := hex.EncodeToString(buyerPrivateKey.PubKey().SerializeCompressed())
-
-	payload := &protobuf.PurchasePayload{
-		DeployID: &protobuf.ActionID{
-			Block:   100,
-			TxIndex: 1,
-		},
-		BuyerPublicKey: buyerPubkeyHex,
-		TimeOutBlock:   uint64(testBlockHeight) + 5,
-		NodeIDs:        []uint32{0, 5, 6, 9},
-		TotalAmountSat: 500,
-	}
-
-	payloadBytes, _ := proto.Marshal(payload)
-	payloadHash := chainhash.DoubleHashB(payloadBytes)
-	signature := ecdsa.Sign(sellerPrivateKey, payloadHash[:])
-	signatureHex := hex.EncodeToString(signature.Serialize())
-
-	message := &protobuf.NodeSaleEvent{
-		Action: protobuf.Action_ACTION_PURCHASE,
-		Purchase: &protobuf.ActionPurchase{
-			Payload:         payload,
-			SellerSignature: signatureHex,
-		},
-	}
-
-	event, block := assembleTestEvent(buyerPrivateKey, "0D0D0D0D", "0D0D0D0D", 0, 0, message)
-	event.InputValue = 400
-
-	mockDgTx.EXPECT().CreateEvent(mock.Anything, mock.MatchedBy(func(event entity.NodeSaleEvent) bool {
-		return event.Valid == false && event.Reason == purchase.INVALID_PAYMENT
-	})).Return(nil)
-
-	err := p.ProcessPurchase(ctx, mockDgTx, block, event)
-	require.NoError(t, err)
-}
-
-func TestInsufficientFund(t *testing.T) {
-	ctx := context.Background()
-	mockDgTx := mocks.NewNodeSaleDataGatewayWithTx(t)
-	p := NewProcessor(mockDgTx, nil, common.NetworkMainnet, nil, 0)
-
-	sellerPrivateKey, _ := btcec.NewPrivateKey()
-	sellerPubkeyHex := hex.EncodeToString(sellerPrivateKey.PubKey().SerializeCompressed())
-	sellerWallet := p.PubkeyToPkHashAddress(sellerPrivateKey.PubKey())
-
-	startAt := time.Now().Add(time.Hour * -1)
-	endAt := time.Now().Add(time.Hour * 1)
-
-	tiers := lo.Map([]*protobuf.Tier{
-		{
-			PriceSat:      100,
-			Limit:         5,
-			MaxPerAddress: 100,
-		},
-		{
-			PriceSat:      200,
-			Limit:         4,
-			MaxPerAddress: 2,
-		},
-		{
-			PriceSat:      400,
-			Limit:         3,
-			MaxPerAddress: 100,
-		},
-	}, func(tier *protobuf.Tier, _ int) []byte {
-		tierJson, err := protojson.Marshal(tier)
-		require.NoError(t, err)
-		return tierJson
-	})
-
-	mockDgTx.EXPECT().GetNodeSale(mock.Anything, datagateway.GetNodeSaleParams{
-		BlockHeight: 100,
-		TxIndex:     1,
-	}).Return([]entity.NodeSale{
-		{
-			BlockHeight:           100,
-			TxIndex:               1,
-			Name:                  t.Name(),
-			StartsAt:              startAt,
-			EndsAt:                endAt,
-			Tiers:                 tiers,
-			SellerPublicKey:       sellerPubkeyHex,
-			MaxPerAddress:         100,
-			DeployTxHash:          "040404040404",
-			MaxDiscountPercentage: 50,
-			SellerWallet:          sellerWallet.EncodeAddress(),
-		},
-	}, nil)
-
-	mockDgTx.EXPECT().GetNodesByIds(mock.Anything, mock.Anything).Return(nil, nil)
-
-	buyerPrivateKey, _ := btcec.NewPrivateKey()
-	buyerPubkeyHex := hex.EncodeToString(buyerPrivateKey.PubKey().SerializeCompressed())
-
-	payload := &protobuf.PurchasePayload{
-		DeployID: &protobuf.ActionID{
-			Block:   100,
-			TxIndex: 1,
-		},
-		BuyerPublicKey: buyerPubkeyHex,
-		TimeOutBlock:   uint64(testBlockHeight) + 5,
-		NodeIDs:        []uint32{0, 5, 6, 9},
-		TotalAmountSat: 200,
-	}
-
-	payloadBytes, _ := proto.Marshal(payload)
-	payloadHash := chainhash.DoubleHashB(payloadBytes)
-	signature := ecdsa.Sign(sellerPrivateKey, payloadHash[:])
-	signatureHex := hex.EncodeToString(signature.Serialize())
-
-	message := &protobuf.NodeSaleEvent{
-		Action: protobuf.Action_ACTION_PURCHASE,
-		Purchase: &protobuf.ActionPurchase{
-			Payload:         payload,
-			SellerSignature: signatureHex,
-		},
-	}
-
-	event, block := assembleTestEvent(buyerPrivateKey, "0D0D0D0D", "0D0D0D0D", 0, 0, message)
-	event.InputValue = 200
-
-	mockDgTx.EXPECT().CreateEvent(mock.Anything, mock.MatchedBy(func(event entity.NodeSaleEvent) bool {
-		return event.Valid == false && event.Reason == purchase.INSUFFICIENT_FUND
-	})).Return(nil)
-
-	err := p.ProcessPurchase(ctx, mockDgTx, block, event)
-	require.NoError(t, err)
-}
-
-func TestBuyingLimit(t *testing.T) {
-	ctx := context.Background()
-	mockDgTx := mocks.NewNodeSaleDataGatewayWithTx(t)
-	p := NewProcessor(mockDgTx, nil, common.NetworkMainnet, nil, 0)
-
-	sellerPrivateKey, _ := btcec.NewPrivateKey()
-	sellerPubkeyHex := hex.EncodeToString(sellerPrivateKey.PubKey().SerializeCompressed())
-	sellerWallet := p.PubkeyToPkHashAddress(sellerPrivateKey.PubKey())
-
-	startAt := time.Now().Add(time.Hour * -1)
-	endAt := time.Now().Add(time.Hour * 1)
-
-	tiers := lo.Map([]*protobuf.Tier{
-		{
-			PriceSat:      100,
-			Limit:         5,
-			MaxPerAddress: 100,
-		},
-		{
-			PriceSat:      200,
-			Limit:         4,
-			MaxPerAddress: 2,
-		},
-		{
-			PriceSat:      400,
-			Limit:         50,
-			MaxPerAddress: 100,
-		},
-	}, func(tier *protobuf.Tier, _ int) []byte {
-		tierJson, err := protojson.Marshal(tier)
-		require.NoError(t, err)
-		return tierJson
-	})
-
-	mockDgTx.EXPECT().GetNodeSale(mock.Anything, datagateway.GetNodeSaleParams{
-		BlockHeight: 100,
-		TxIndex:     1,
-	}).Return([]entity.NodeSale{
-		{
-			BlockHeight:           100,
-			TxIndex:               1,
-			Name:                  t.Name(),
-			StartsAt:              startAt,
-			EndsAt:                endAt,
-			Tiers:                 tiers,
-			SellerPublicKey:       sellerPubkeyHex,
-			MaxPerAddress:         2,
-			DeployTxHash:          "040404040404",
-			MaxDiscountPercentage: 50,
-			SellerWallet:          sellerWallet.EncodeAddress(),
-		},
-	}, nil)
-
-	buyerPrivateKey, _ := btcec.NewPrivateKey()
-	buyerPubkeyHex := hex.EncodeToString(buyerPrivateKey.PubKey().SerializeCompressed())
-
-	mockDgTx.EXPECT().GetNodesByIds(mock.Anything, mock.Anything).Return(nil, nil)
-
-	mockDgTx.EXPECT().GetNodesByOwner(mock.Anything, datagateway.GetNodesByOwnerParams{
-		SaleBlock:      100,
-		SaleTxIndex:    1,
-		OwnerPublicKey: buyerPubkeyHex,
-	}).Return([]entity.Node{
-		{
-			SaleBlock:      100,
-			SaleTxIndex:    1,
-			NodeID:         9,
-			TierIndex:      2,
-			OwnerPublicKey: buyerPubkeyHex,
-		},
-		{
-			SaleBlock:      100,
-			SaleTxIndex:    1,
-			NodeID:         10,
-			TierIndex:      2,
-			OwnerPublicKey: buyerPubkeyHex,
-		},
-	}, nil)
-
-	payload := &protobuf.PurchasePayload{
-		DeployID: &protobuf.ActionID{
-			Block:   100,
-			TxIndex: 1,
-		},
-		BuyerPublicKey: buyerPubkeyHex,
-		TimeOutBlock:   uint64(testBlockHeight) + 5,
-		NodeIDs:        []uint32{11},
-		TotalAmountSat: 600,
-	}
-
-	payloadBytes, _ := proto.Marshal(payload)
-	payloadHash := chainhash.DoubleHashB(payloadBytes)
-	signature := ecdsa.Sign(sellerPrivateKey, payloadHash[:])
-	signatureHex := hex.EncodeToString(signature.Serialize())
-
-	message := &protobuf.NodeSaleEvent{
-		Action: protobuf.Action_ACTION_PURCHASE,
-		Purchase: &protobuf.ActionPurchase{
-			Payload:         payload,
-			SellerSignature: signatureHex,
-		},
-	}
-
-	event, block := assembleTestEvent(buyerPrivateKey, "22222222", "22222222", 0, 0, message)
-	event.InputValue = 600
-
-	mockDgTx.EXPECT().CreateEvent(mock.Anything, mock.MatchedBy(func(event entity.NodeSaleEvent) bool {
-		return event.Valid == false && event.Reason == purchase.OVER_LIMIT_PER_ADDR
-	})).Return(nil)
-
-	err := p.ProcessPurchase(ctx, mockDgTx, block, event)
-	require.NoError(t, err)
-
-	mockDgTx.AssertNotCalled(t, "CreateNode")
-}
-
-func TestBuyingTierLimit(t *testing.T) {
-	ctx := context.Background()
-	mockDgTx := mocks.NewNodeSaleDataGatewayWithTx(t)
-	p := NewProcessor(mockDgTx, nil, common.NetworkMainnet, nil, 0)
-
-	sellerPrivateKey, _ := btcec.NewPrivateKey()
-	sellerPubkeyHex := hex.EncodeToString(sellerPrivateKey.PubKey().SerializeCompressed())
-	sellerWallet := p.PubkeyToPkHashAddress(sellerPrivateKey.PubKey())
-
-	startAt := time.Now().Add(time.Hour * -1)
-	endAt := time.Now().Add(time.Hour * 1)
-
-	tiers := lo.Map([]*protobuf.Tier{
-		{
-			PriceSat:      100,
-			Limit:         5,
-			MaxPerAddress: 100,
-		},
-		{
-			PriceSat:      200,
-			Limit:         4,
-			MaxPerAddress: 2,
-		},
-		{
-			PriceSat:      400,
-			Limit:         50,
-			MaxPerAddress: 3,
-		},
-	}, func(tier *protobuf.Tier, _ int) []byte {
-		tierJson, err := protojson.Marshal(tier)
-		require.NoError(t, err)
-		return tierJson
-	})
-
-	mockDgTx.EXPECT().GetNodeSale(mock.Anything, datagateway.GetNodeSaleParams{
-		BlockHeight: 100,
-		TxIndex:     1,
-	}).Return([]entity.NodeSale{
-		{
-			BlockHeight:           100,
-			TxIndex:               1,
-			Name:                  t.Name(),
-			StartsAt:              startAt,
-			EndsAt:                endAt,
-			Tiers:                 tiers,
-			SellerPublicKey:       sellerPubkeyHex,
-			MaxPerAddress:         100,
-			DeployTxHash:          "040404040404",
-			MaxDiscountPercentage: 50,
-			SellerWallet:          sellerWallet.EncodeAddress(),
-		},
-	}, nil)
-
-	buyerPrivateKey, _ := btcec.NewPrivateKey()
-	buyerPubkeyHex := hex.EncodeToString(buyerPrivateKey.PubKey().SerializeCompressed())
-
-	mockDgTx.EXPECT().GetNodesByIds(mock.Anything, mock.Anything).Return(nil, nil)
-
-	mockDgTx.EXPECT().GetNodesByOwner(mock.Anything, datagateway.GetNodesByOwnerParams{
-		SaleBlock:      100,
-		SaleTxIndex:    1,
-		OwnerPublicKey: buyerPubkeyHex,
-	}).Return([]entity.Node{
-		{
-			SaleBlock:      100,
-			SaleTxIndex:    1,
-			NodeID:         9,
-			TierIndex:      2,
-			OwnerPublicKey: buyerPubkeyHex,
-		},
-		{
-			SaleBlock:      100,
-			SaleTxIndex:    1,
-			NodeID:         10,
-			TierIndex:      2,
-			OwnerPublicKey: buyerPubkeyHex,
-		},
-		{
-			SaleBlock:      100,
-			SaleTxIndex:    1,
-			NodeID:         11,
-			TierIndex:      2,
-			OwnerPublicKey: buyerPubkeyHex,
-		},
-	}, nil)
-
-	payload := &protobuf.PurchasePayload{
-		DeployID: &protobuf.ActionID{
-			Block:   100,
-			TxIndex: 1,
-		},
-		BuyerPublicKey: buyerPubkeyHex,
-		TimeOutBlock:   uint64(testBlockHeight) + 5,
-		NodeIDs:        []uint32{12, 13, 14},
-		TotalAmountSat: 600,
-	}
-
-	payloadBytes, _ := proto.Marshal(payload)
-	payloadHash := chainhash.DoubleHashB(payloadBytes)
-	signature := ecdsa.Sign(sellerPrivateKey, payloadHash[:])
-	signatureHex := hex.EncodeToString(signature.Serialize())
-
-	message := &protobuf.NodeSaleEvent{
-		Action: protobuf.Action_ACTION_PURCHASE,
-		Purchase: &protobuf.ActionPurchase{
-			Payload:         payload,
-			SellerSignature: signatureHex,
-		},
-	}
-
-	event, block := assembleTestEvent(buyerPrivateKey, "10101010", "10101010", 0, 0, message)
-	event.InputValue = 600
-
-	mockDgTx.EXPECT().CreateEvent(mock.Anything, mock.MatchedBy(func(event entity.NodeSaleEvent) bool {
-		return event.Valid == false && event.Reason == purchase.OVER_LIMIT_PER_TIER
-	})).Return(nil)
-
-	err := p.ProcessPurchase(ctx, mockDgTx, block, event)
-	require.NoError(t, err)
-}

modules/nodesale/repository/postgres/gen/blocks.sql.go

@@ -1,62 +0,0 @@
-// Code generated by sqlc. DO NOT EDIT.
-// versions:
-//   sqlc v1.27.0
-// source: blocks.sql
-
-package gen
-
-import (
-	"context"
-)
-
-const createBlock = `-- name: CreateBlock :exec
-INSERT INTO blocks ("block_height", "block_hash", "module")
-VALUES ($1, $2, $3)
-`
-
-type CreateBlockParams struct {
-	BlockHeight int64
-	BlockHash   string
-	Module      string
-}
-
-func (q *Queries) CreateBlock(ctx context.Context, arg CreateBlockParams) error {
-	_, err := q.db.Exec(ctx, createBlock, arg.BlockHeight, arg.BlockHash, arg.Module)
-	return err
-}
-
-const getBlock = `-- name: GetBlock :one
-SELECT block_height, block_hash, module FROM blocks
-WHERE "block_height" = $1
-`
-
-func (q *Queries) GetBlock(ctx context.Context, blockHeight int64) (Block, error) {
-	row := q.db.QueryRow(ctx, getBlock, blockHeight)
-	var i Block
-	err := row.Scan(&i.BlockHeight, &i.BlockHash, &i.Module)
-	return i, err
-}
-
-const getLastProcessedBlock = `-- name: GetLastProcessedBlock :one
-SELECT block_height, block_hash, module FROM blocks ORDER BY block_height DESC LIMIT 1
-`
-
-func (q *Queries) GetLastProcessedBlock(ctx context.Context) (Block, error) {
-	row := q.db.QueryRow(ctx, getLastProcessedBlock)
-	var i Block
-	err := row.Scan(&i.BlockHeight, &i.BlockHash, &i.Module)
-	return i, err
-}
-
-const removeBlockFrom = `-- name: RemoveBlockFrom :execrows
-DELETE FROM blocks
-WHERE "block_height" >= $1
-`
-
-func (q *Queries) RemoveBlockFrom(ctx context.Context, fromBlock int64) (int64, error) {
-	result, err := q.db.Exec(ctx, removeBlockFrom, fromBlock)
-	if err != nil {
-		return 0, err
-	}
-	return result.RowsAffected(), nil
-}

modules/nodesale/repository/postgres/gen/db.go

@@ -1,32 +0,0 @@
-// Code generated by sqlc. DO NOT EDIT.
-// versions:
-//   sqlc v1.27.0
-
-package gen
-
-import (
-	"context"
-
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgconn"
-)
-
-type DBTX interface {
-	Exec(context.Context, string, ...interface{}) (pgconn.CommandTag, error)
-	Query(context.Context, string, ...interface{}) (pgx.Rows, error)
-	QueryRow(context.Context, string, ...interface{}) pgx.Row
-}
-
-func New(db DBTX) *Queries {
-	return &Queries{db: db}
-}
-
-type Queries struct {
-	db DBTX
-}
-
-func (q *Queries) WithTx(tx pgx.Tx) *Queries {
-	return &Queries{
-		db: tx,
-	}
-}

modules/nodesale/repository/postgres/gen/events.sql.go

@@ -1,104 +0,0 @@
-// Code generated by sqlc. DO NOT EDIT.
-// versions:
-//   sqlc v1.27.0
-// source: events.sql
-
-package gen
-
-import (
-	"context"
-
-	"github.com/jackc/pgx/v5/pgtype"
-)
-
-const createEvent = `-- name: CreateEvent :exec
-INSERT INTO events ("tx_hash", "block_height", "tx_index", "wallet_address", "valid", "action", 
-                    "raw_message", "parsed_message", "block_timestamp", "block_hash", "metadata",
-                    "reason")
-VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
-`
-
-type CreateEventParams struct {
-	TxHash         string
-	BlockHeight    int64
-	TxIndex        int32
-	WalletAddress  string
-	Valid          bool
-	Action         int32
-	RawMessage     []byte
-	ParsedMessage  []byte
-	BlockTimestamp pgtype.Timestamp
-	BlockHash      string
-	Metadata       []byte
-	Reason         string
-}
-
-func (q *Queries) CreateEvent(ctx context.Context, arg CreateEventParams) error {
-	_, err := q.db.Exec(ctx, createEvent,
-		arg.TxHash,
-		arg.BlockHeight,
-		arg.TxIndex,
-		arg.WalletAddress,
-		arg.Valid,
-		arg.Action,
-		arg.RawMessage,
-		arg.ParsedMessage,
-		arg.BlockTimestamp,
-		arg.BlockHash,
-		arg.Metadata,
-		arg.Reason,
-	)
-	return err
-}
-
-const getEventsByWallet = `-- name: GetEventsByWallet :many
-SELECT tx_hash, block_height, tx_index, wallet_address, valid, action, raw_message, parsed_message, block_timestamp, block_hash, metadata, reason
-FROM events
-WHERE wallet_address = $1
-`
-
-func (q *Queries) GetEventsByWallet(ctx context.Context, walletAddress string) ([]Event, error) {
-	rows, err := q.db.Query(ctx, getEventsByWallet, walletAddress)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var items []Event
-	for rows.Next() {
-		var i Event
-		if err := rows.Scan(
-			&i.TxHash,
-			&i.BlockHeight,
-			&i.TxIndex,
-			&i.WalletAddress,
-			&i.Valid,
-			&i.Action,
-			&i.RawMessage,
-			&i.ParsedMessage,
-			&i.BlockTimestamp,
-			&i.BlockHash,
-			&i.Metadata,
-			&i.Reason,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const removeEventsFromBlock = `-- name: RemoveEventsFromBlock :execrows
-DELETE FROM events
-WHERE "block_height" >= $1
-`
-
-func (q *Queries) RemoveEventsFromBlock(ctx context.Context, fromBlock int64) (int64, error) {
-	result, err := q.db.Exec(ctx, removeEventsFromBlock, fromBlock)
-	if err != nil {
-		return 0, err
-	}
-	return result.RowsAffected(), nil
-}

modules/nodesale/repository/postgres/gen/models.go

@@ -1,55 +0,0 @@
-// Code generated by sqlc. DO NOT EDIT.
-// versions:
-//   sqlc v1.27.0
-
-package gen
-
-import (
-	"github.com/jackc/pgx/v5/pgtype"
-)
-
-type Block struct {
-	BlockHeight int64
-	BlockHash   string
-	Module      string
-}
-
-type Event struct {
-	TxHash         string
-	BlockHeight    int64
-	TxIndex        int32
-	WalletAddress  string
-	Valid          bool
-	Action         int32
-	RawMessage     []byte
-	ParsedMessage  []byte
-	BlockTimestamp pgtype.Timestamp
-	BlockHash      string
-	Metadata       []byte
-	Reason         string
-}
-
-type Node struct {
-	SaleBlock      int64
-	SaleTxIndex    int32
-	NodeID         int32
-	TierIndex      int32
-	DelegatedTo    string
-	OwnerPublicKey string
-	PurchaseTxHash string
-	DelegateTxHash string
-}
-
-type NodeSale struct {
-	BlockHeight           int64
-	TxIndex               int32
-	Name                  string
-	StartsAt              pgtype.Timestamp
-	EndsAt                pgtype.Timestamp
-	Tiers                 [][]byte
-	SellerPublicKey       string
-	MaxPerAddress         int32
-	DeployTxHash          string
-	MaxDiscountPercentage int32
-	SellerWallet          string
-}

modules/nodesale/repository/postgres/gen/nodes.sql.go

@@ -1,312 +0,0 @@
-// Code generated by sqlc. DO NOT EDIT.
-// versions:
-//   sqlc v1.27.0
-// source: nodes.sql
-
-package gen
-
-import (
-	"context"
-)
-
-const clearDelegate = `-- name: ClearDelegate :execrows
-UPDATE nodes
-SET "delegated_to" = ''
-WHERE "delegate_tx_hash" = ''
-`
-
-func (q *Queries) ClearDelegate(ctx context.Context) (int64, error) {
-	result, err := q.db.Exec(ctx, clearDelegate)
-	if err != nil {
-		return 0, err
-	}
-	return result.RowsAffected(), nil
-}
-
-const createNode = `-- name: CreateNode :exec
-INSERT INTO nodes (sale_block, sale_tx_index, node_id, tier_index, delegated_to, owner_public_key, purchase_tx_hash, delegate_tx_hash)
-VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
-`
-
-type CreateNodeParams struct {
-	SaleBlock      int64
-	SaleTxIndex    int32
-	NodeID         int32
-	TierIndex      int32
-	DelegatedTo    string
-	OwnerPublicKey string
-	PurchaseTxHash string
-	DelegateTxHash string
-}
-
-func (q *Queries) CreateNode(ctx context.Context, arg CreateNodeParams) error {
-	_, err := q.db.Exec(ctx, createNode,
-		arg.SaleBlock,
-		arg.SaleTxIndex,
-		arg.NodeID,
-		arg.TierIndex,
-		arg.DelegatedTo,
-		arg.OwnerPublicKey,
-		arg.PurchaseTxHash,
-		arg.DelegateTxHash,
-	)
-	return err
-}
-
-const getNodeCountByTierIndex = `-- name: GetNodeCountByTierIndex :many
-SELECT (tiers.tier_index)::int AS tier_index, count(nodes.tier_index)
-FROM generate_series($3::int,$4::int) AS tiers(tier_index)
-LEFT JOIN 
-	(SELECT sale_block, sale_tx_index, node_id, tier_index, delegated_to, owner_public_key, purchase_tx_hash, delegate_tx_hash 
-	FROM nodes 
-	WHERE sale_block = $1 AND 
-		sale_tx_index= $2) 
-	AS nodes ON tiers.tier_index = nodes.tier_index 
-GROUP BY tiers.tier_index
-ORDER BY tiers.tier_index
-`
-
-type GetNodeCountByTierIndexParams struct {
-	SaleBlock   int64
-	SaleTxIndex int32
-	FromTier    int32
-	ToTier      int32
-}
-
-type GetNodeCountByTierIndexRow struct {
-	TierIndex int32
-	Count     int64
-}
-
-func (q *Queries) GetNodeCountByTierIndex(ctx context.Context, arg GetNodeCountByTierIndexParams) ([]GetNodeCountByTierIndexRow, error) {
-	rows, err := q.db.Query(ctx, getNodeCountByTierIndex,
-		arg.SaleBlock,
-		arg.SaleTxIndex,
-		arg.FromTier,
-		arg.ToTier,
-	)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var items []GetNodeCountByTierIndexRow
-	for rows.Next() {
-		var i GetNodeCountByTierIndexRow
-		if err := rows.Scan(&i.TierIndex, &i.Count); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const getNodesByDeployment = `-- name: GetNodesByDeployment :many
-SELECT sale_block, sale_tx_index, node_id, tier_index, delegated_to, owner_public_key, purchase_tx_hash, delegate_tx_hash 
-FROM nodes
-WHERE sale_block = $1 AND
-    sale_tx_index = $2
-`
-
-type GetNodesByDeploymentParams struct {
-	SaleBlock   int64
-	SaleTxIndex int32
-}
-
-func (q *Queries) GetNodesByDeployment(ctx context.Context, arg GetNodesByDeploymentParams) ([]Node, error) {
-	rows, err := q.db.Query(ctx, getNodesByDeployment, arg.SaleBlock, arg.SaleTxIndex)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var items []Node
-	for rows.Next() {
-		var i Node
-		if err := rows.Scan(
-			&i.SaleBlock,
-			&i.SaleTxIndex,
-			&i.NodeID,
-			&i.TierIndex,
-			&i.DelegatedTo,
-			&i.OwnerPublicKey,
-			&i.PurchaseTxHash,
-			&i.DelegateTxHash,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const getNodesByIds = `-- name: GetNodesByIds :many
-SELECT sale_block, sale_tx_index, node_id, tier_index, delegated_to, owner_public_key, purchase_tx_hash, delegate_tx_hash
-FROM nodes
-WHERE sale_block = $1 AND
-    sale_tx_index = $2 AND
-    node_id = ANY ($3::int[])
-`
-
-type GetNodesByIdsParams struct {
-	SaleBlock   int64
-	SaleTxIndex int32
-	NodeIds     []int32
-}
-
-func (q *Queries) GetNodesByIds(ctx context.Context, arg GetNodesByIdsParams) ([]Node, error) {
-	rows, err := q.db.Query(ctx, getNodesByIds, arg.SaleBlock, arg.SaleTxIndex, arg.NodeIds)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var items []Node
-	for rows.Next() {
-		var i Node
-		if err := rows.Scan(
-			&i.SaleBlock,
-			&i.SaleTxIndex,
-			&i.NodeID,
-			&i.TierIndex,
-			&i.DelegatedTo,
-			&i.OwnerPublicKey,
-			&i.PurchaseTxHash,
-			&i.DelegateTxHash,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const getNodesByOwner = `-- name: GetNodesByOwner :many
-SELECT sale_block, sale_tx_index, node_id, tier_index, delegated_to, owner_public_key, purchase_tx_hash, delegate_tx_hash 
-FROM nodes
-WHERE sale_block = $1 AND
-    sale_tx_index = $2 AND
-    owner_public_key = $3
-ORDER BY tier_index
-`
-
-type GetNodesByOwnerParams struct {
-	SaleBlock      int64
-	SaleTxIndex    int32
-	OwnerPublicKey string
-}
-
-func (q *Queries) GetNodesByOwner(ctx context.Context, arg GetNodesByOwnerParams) ([]Node, error) {
-	rows, err := q.db.Query(ctx, getNodesByOwner, arg.SaleBlock, arg.SaleTxIndex, arg.OwnerPublicKey)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var items []Node
-	for rows.Next() {
-		var i Node
-		if err := rows.Scan(
-			&i.SaleBlock,
-			&i.SaleTxIndex,
-			&i.NodeID,
-			&i.TierIndex,
-			&i.DelegatedTo,
-			&i.OwnerPublicKey,
-			&i.PurchaseTxHash,
-			&i.DelegateTxHash,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const getNodesByPubkey = `-- name: GetNodesByPubkey :many
-SELECT nodes.sale_block, nodes.sale_tx_index, nodes.node_id, nodes.tier_index, nodes.delegated_to, nodes.owner_public_key, nodes.purchase_tx_hash, nodes.delegate_tx_hash
-FROM nodes JOIN events ON nodes.purchase_tx_hash = events.tx_hash
-WHERE sale_block = $1 AND
-    sale_tx_index = $2 AND
-    owner_public_key = $3 AND
-    delegated_to = $4
-`
-
-type GetNodesByPubkeyParams struct {
-	SaleBlock      int64
-	SaleTxIndex    int32
-	OwnerPublicKey string
-	DelegatedTo    string
-}
-
-func (q *Queries) GetNodesByPubkey(ctx context.Context, arg GetNodesByPubkeyParams) ([]Node, error) {
-	rows, err := q.db.Query(ctx, getNodesByPubkey,
-		arg.SaleBlock,
-		arg.SaleTxIndex,
-		arg.OwnerPublicKey,
-		arg.DelegatedTo,
-	)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var items []Node
-	for rows.Next() {
-		var i Node
-		if err := rows.Scan(
-			&i.SaleBlock,
-			&i.SaleTxIndex,
-			&i.NodeID,
-			&i.TierIndex,
-			&i.DelegatedTo,
-			&i.OwnerPublicKey,
-			&i.PurchaseTxHash,
-			&i.DelegateTxHash,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const setDelegates = `-- name: SetDelegates :execrows
-UPDATE nodes
-SET delegated_to = $4, delegate_tx_hash = $3
-WHERE sale_block = $1 AND
-    sale_tx_index = $2 AND
-    node_id = ANY ($5::int[])
-`
-
-type SetDelegatesParams struct {
-	SaleBlock      int64
-	SaleTxIndex    int32
-	DelegateTxHash string
-	Delegatee      string
-	NodeIds        []int32
-}
-
-func (q *Queries) SetDelegates(ctx context.Context, arg SetDelegatesParams) (int64, error) {
-	result, err := q.db.Exec(ctx, setDelegates,
-		arg.SaleBlock,
-		arg.SaleTxIndex,
-		arg.DelegateTxHash,
-		arg.Delegatee,
-		arg.NodeIds,
-	)
-	if err != nil {
-		return 0, err
-	}
-	return result.RowsAffected(), nil
-}

modules/nodesale/repository/postgres/gen/nodesales.sql.go

@@ -1,92 +0,0 @@
-// Code generated by sqlc. DO NOT EDIT.
-// versions:
-//   sqlc v1.27.0
-// source: nodesales.sql
-
-package gen
-
-import (
-	"context"
-
-	"github.com/jackc/pgx/v5/pgtype"
-)
-
-const createNodeSale = `-- name: CreateNodeSale :exec
-INSERT INTO node_sales ("block_height", "tx_index", "name", "starts_at", "ends_at", "tiers", "seller_public_key", "max_per_address", "deploy_tx_hash", "max_discount_percentage", "seller_wallet")
-VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
-`
-
-type CreateNodeSaleParams struct {
-	BlockHeight           int64
-	TxIndex               int32
-	Name                  string
-	StartsAt              pgtype.Timestamp
-	EndsAt                pgtype.Timestamp
-	Tiers                 [][]byte
-	SellerPublicKey       string
-	MaxPerAddress         int32
-	DeployTxHash          string
-	MaxDiscountPercentage int32
-	SellerWallet          string
-}
-
-func (q *Queries) CreateNodeSale(ctx context.Context, arg CreateNodeSaleParams) error {
-	_, err := q.db.Exec(ctx, createNodeSale,
-		arg.BlockHeight,
-		arg.TxIndex,
-		arg.Name,
-		arg.StartsAt,
-		arg.EndsAt,
-		arg.Tiers,
-		arg.SellerPublicKey,
-		arg.MaxPerAddress,
-		arg.DeployTxHash,
-		arg.MaxDiscountPercentage,
-		arg.SellerWallet,
-	)
-	return err
-}
-
-const getNodeSale = `-- name: GetNodeSale :many
-SELECT block_height, tx_index, name, starts_at, ends_at, tiers, seller_public_key, max_per_address, deploy_tx_hash, max_discount_percentage, seller_wallet
-FROM node_sales
-WHERE block_height = $1 AND
-    tx_index = $2
-`
-
-type GetNodeSaleParams struct {
-	BlockHeight int64
-	TxIndex     int32
-}
-
-func (q *Queries) GetNodeSale(ctx context.Context, arg GetNodeSaleParams) ([]NodeSale, error) {
-	rows, err := q.db.Query(ctx, getNodeSale, arg.BlockHeight, arg.TxIndex)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var items []NodeSale
-	for rows.Next() {
-		var i NodeSale
-		if err := rows.Scan(
-			&i.BlockHeight,
-			&i.TxIndex,
-			&i.Name,
-			&i.StartsAt,
-			&i.EndsAt,
-			&i.Tiers,
-			&i.SellerPublicKey,
-			&i.MaxPerAddress,
-			&i.DeployTxHash,
-			&i.MaxDiscountPercentage,
-			&i.SellerWallet,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}

modules/nodesale/repository/postgres/gen/test.sql.go

@@ -1,20 +0,0 @@
-// Code generated by sqlc. DO NOT EDIT.
-// versions:
-//   sqlc v1.27.0
-// source: test.sql
-
-package gen
-
-import (
-	"context"
-)
-
-const clearEvents = `-- name: ClearEvents :exec
-DELETE FROM events
-WHERE tx_hash <> ''
-`
-
-func (q *Queries) ClearEvents(ctx context.Context) error {
-	_, err := q.db.Exec(ctx, clearEvents)
-	return err
-}

modules/nodesale/repository/postgres/mapper.go

@@ -1,74 +0,0 @@
-package postgres
-
-import (
-	"encoding/json"
-
-	"github.com/gaze-network/indexer-network/modules/nodesale/datagateway"
-	"github.com/gaze-network/indexer-network/modules/nodesale/internal/entity"
-	"github.com/gaze-network/indexer-network/modules/nodesale/repository/postgres/gen"
-	"github.com/samber/lo"
-)
-
-func mapNodes(nodes []gen.Node) []entity.Node {
-	return lo.Map(nodes, func(item gen.Node, index int) entity.Node {
-		return entity.Node{
-			SaleBlock:      uint64(item.SaleBlock),
-			SaleTxIndex:    uint32(item.SaleTxIndex),
-			NodeID:         uint32(item.NodeID),
-			TierIndex:      item.TierIndex,
-			DelegatedTo:    item.DelegatedTo,
-			OwnerPublicKey: item.OwnerPublicKey,
-			PurchaseTxHash: item.PurchaseTxHash,
-			DelegateTxHash: item.DelegateTxHash,
-		}
-	})
-}
-
-func mapNodeSales(nodeSales []gen.NodeSale) []entity.NodeSale {
-	return lo.Map(nodeSales, func(item gen.NodeSale, index int) entity.NodeSale {
-		return entity.NodeSale{
-			BlockHeight:           uint64(item.BlockHeight),
-			TxIndex:               uint32(item.TxIndex),
-			Name:                  item.Name,
-			StartsAt:              item.StartsAt.Time,
-			EndsAt:                item.EndsAt.Time,
-			Tiers:                 item.Tiers,
-			SellerPublicKey:       item.SellerPublicKey,
-			MaxPerAddress:         uint32(item.MaxPerAddress),
-			DeployTxHash:          item.DeployTxHash,
-			MaxDiscountPercentage: item.MaxDiscountPercentage,
-			SellerWallet:          item.SellerWallet,
-		}
-	})
-}
-
-func mapNodeCountByTierIndexRows(nodeCount []gen.GetNodeCountByTierIndexRow) []datagateway.GetNodeCountByTierIndexRow {
-	return lo.Map(nodeCount, func(item gen.GetNodeCountByTierIndexRow, index int) datagateway.GetNodeCountByTierIndexRow {
-		return datagateway.GetNodeCountByTierIndexRow{
-			TierIndex: item.TierIndex,
-		}
-	})
-}
-
-func mapNodeSalesEvents(events []gen.Event) []entity.NodeSaleEvent {
-	return lo.Map(events, func(item gen.Event, index int) entity.NodeSaleEvent {
-		var meta entity.MetadataEventPurchase
-		err := json.Unmarshal(item.Metadata, &meta)
-		if err != nil {
-			meta = entity.MetadataEventPurchase{}
-		}
-		return entity.NodeSaleEvent{
-			TxHash:         item.TxHash,
-			BlockHeight:    item.BlockHeight,
-			TxIndex:        item.TxIndex,
-			WalletAddress:  item.WalletAddress,
-			Valid:          item.Valid,
-			Action:         item.Action,
-			RawMessage:     item.RawMessage,
-			ParsedMessage:  item.ParsedMessage,
-			BlockTimestamp: item.BlockTimestamp.Time.UTC(),
-			BlockHash:      item.BlockHash,
-			Metadata:       &meta,
-		}
-	})
-}

modules/nodesale/repository/postgres/repository.go

@@ -1,247 +0,0 @@
-package postgres
-
-import (
-	"context"
-	"encoding/json"
-
-	"github.com/cockroachdb/errors"
-	"github.com/gaze-network/indexer-network/internal/postgres"
-	"github.com/gaze-network/indexer-network/modules/nodesale/datagateway"
-	"github.com/gaze-network/indexer-network/modules/nodesale/internal/entity"
-	"github.com/gaze-network/indexer-network/modules/nodesale/repository/postgres/gen"
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgtype"
-	"github.com/samber/lo"
-)
-
-type Repository struct {
-	db      postgres.DB
-	queries *gen.Queries
-	tx      pgx.Tx
-}
-
-func NewRepository(db postgres.DB) *Repository {
-	return &Repository{
-		db:      db,
-		queries: gen.New(db),
-	}
-}
-
-func (repo *Repository) CreateBlock(ctx context.Context, arg entity.Block) error {
-	err := repo.queries.CreateBlock(ctx, gen.CreateBlockParams{
-		BlockHeight: arg.BlockHeight,
-		BlockHash:   arg.BlockHash,
-		Module:      arg.Module,
-	})
-	if err != nil {
-		return errors.Wrap(err, "Cannot Add block")
-	}
-
-	return nil
-}
-
-func (repo *Repository) GetBlock(ctx context.Context, blockHeight int64) (*entity.Block, error) {
-	block, err := repo.queries.GetBlock(ctx, blockHeight)
-	if err != nil {
-		return nil, errors.Wrap(err, "Cannot get block")
-	}
-	return &entity.Block{
-		BlockHeight: block.BlockHeight,
-		BlockHash:   block.BlockHash,
-		Module:      block.Module,
-	}, nil
-}
-
-func (repo *Repository) GetLastProcessedBlock(ctx context.Context) (*entity.Block, error) {
-	block, err := repo.queries.GetLastProcessedBlock(ctx)
-	if err != nil {
-		return nil, errors.Wrap(err, "Cannot get last processed block")
-	}
-	return &entity.Block{
-		BlockHeight: block.BlockHeight,
-		BlockHash:   block.BlockHash,
-		Module:      block.Module,
-	}, nil
-}
-
-func (repo *Repository) RemoveBlockFrom(ctx context.Context, fromBlock int64) (int64, error) {
-	affected, err := repo.queries.RemoveBlockFrom(ctx, fromBlock)
-	if err != nil {
-		return 0, errors.Wrap(err, "Cannot remove blocks")
-	}
-	return affected, nil
-}
-
-func (repo *Repository) RemoveEventsFromBlock(ctx context.Context, fromBlock int64) (int64, error) {
-	affected, err := repo.queries.RemoveEventsFromBlock(ctx, fromBlock)
-	if err != nil {
-		return 0, errors.Wrap(err, "Cannot remove events")
-	}
-	return affected, nil
-}
-
-func (repo *Repository) ClearDelegate(ctx context.Context) (int64, error) {
-	affected, err := repo.queries.ClearDelegate(ctx)
-	if err != nil {
-		return 0, errors.Wrap(err, "Cannot clear delegate")
-	}
-	return affected, nil
-}
-
-func (repo *Repository) GetNodesByIds(ctx context.Context, arg datagateway.GetNodesByIdsParams) ([]entity.Node, error) {
-	nodes, err := repo.queries.GetNodesByIds(ctx, gen.GetNodesByIdsParams{
-		SaleBlock:   int64(arg.SaleBlock),
-		SaleTxIndex: int32(arg.SaleTxIndex),
-		NodeIds:     lo.Map(arg.NodeIds, func(item uint32, index int) int32 { return int32(item) }),
-	})
-	if err != nil {
-		return nil, errors.Wrap(err, "Cannot get nodes")
-	}
-	return mapNodes(nodes), nil
-}
-
-func (repo *Repository) CreateEvent(ctx context.Context, arg entity.NodeSaleEvent) error {
-	metaDataBytes := []byte("{}")
-	if arg.Metadata != nil {
-		metaDataBytes, _ = json.Marshal(arg.Metadata)
-	}
-	err := repo.queries.CreateEvent(ctx, gen.CreateEventParams{
-		TxHash:         arg.TxHash,
-		BlockHeight:    arg.BlockHeight,
-		TxIndex:        arg.TxIndex,
-		WalletAddress:  arg.WalletAddress,
-		Valid:          arg.Valid,
-		Action:         arg.Action,
-		RawMessage:     arg.RawMessage,
-		ParsedMessage:  arg.ParsedMessage,
-		BlockTimestamp: pgtype.Timestamp{Time: arg.BlockTimestamp.UTC(), Valid: true},
-		BlockHash:      arg.BlockHash,
-		Metadata:       metaDataBytes,
-		Reason:         arg.Reason,
-	})
-	if err != nil {
-		return errors.Wrap(err, "Cannot add event")
-	}
-	return nil
-}
-
-func (repo *Repository) SetDelegates(ctx context.Context, arg datagateway.SetDelegatesParams) (int64, error) {
-	affected, err := repo.queries.SetDelegates(ctx, gen.SetDelegatesParams{
-		SaleBlock:      int64(arg.SaleBlock),
-		SaleTxIndex:    arg.SaleTxIndex,
-		Delegatee:      arg.Delegatee,
-		DelegateTxHash: arg.DelegateTxHash,
-		NodeIds:        lo.Map(arg.NodeIds, func(item uint32, index int) int32 { return int32(item) }),
-	})
-	if err != nil {
-		return 0, errors.Wrap(err, "Cannot set delegate")
-	}
-	return affected, nil
-}
-
-func (repo *Repository) CreateNodeSale(ctx context.Context, arg entity.NodeSale) error {
-	err := repo.queries.CreateNodeSale(ctx, gen.CreateNodeSaleParams{
-		BlockHeight:           int64(arg.BlockHeight),
-		TxIndex:               int32(arg.TxIndex),
-		Name:                  arg.Name,
-		StartsAt:              pgtype.Timestamp{Time: arg.StartsAt.UTC(), Valid: true},
-		EndsAt:                pgtype.Timestamp{Time: arg.EndsAt.UTC(), Valid: true},
-		Tiers:                 arg.Tiers,
-		SellerPublicKey:       arg.SellerPublicKey,
-		MaxPerAddress:         int32(arg.MaxPerAddress),
-		DeployTxHash:          arg.DeployTxHash,
-		MaxDiscountPercentage: arg.MaxDiscountPercentage,
-		SellerWallet:          arg.SellerWallet,
-	})
-	if err != nil {
-		return errors.Wrap(err, "Cannot add NodeSale")
-	}
-	return nil
-}
-
-func (repo *Repository) GetNodeSale(ctx context.Context, arg datagateway.GetNodeSaleParams) ([]entity.NodeSale, error) {
-	nodeSales, err := repo.queries.GetNodeSale(ctx, gen.GetNodeSaleParams{
-		BlockHeight: int64(arg.BlockHeight),
-		TxIndex:     int32(arg.TxIndex),
-	})
-	if err != nil {
-		return nil, errors.Wrap(err, "Cannot get NodeSale")
-	}
-
-	return mapNodeSales(nodeSales), nil
-}
-
-func (repo *Repository) GetNodesByOwner(ctx context.Context, arg datagateway.GetNodesByOwnerParams) ([]entity.Node, error) {
-	nodes, err := repo.queries.GetNodesByOwner(ctx, gen.GetNodesByOwnerParams{
-		SaleBlock:      int64(arg.SaleBlock),
-		SaleTxIndex:    int32(arg.SaleTxIndex),
-		OwnerPublicKey: arg.OwnerPublicKey,
-	})
-	if err != nil {
-		return nil, errors.Wrap(err, "Cannot get nodes by owner")
-	}
-	return mapNodes(nodes), nil
-}
-
-func (repo *Repository) CreateNode(ctx context.Context, arg entity.Node) error {
-	err := repo.queries.CreateNode(ctx, gen.CreateNodeParams{
-		SaleBlock:      int64(arg.SaleBlock),
-		SaleTxIndex:    int32(arg.SaleTxIndex),
-		NodeID:         int32(arg.NodeID),
-		TierIndex:      arg.TierIndex,
-		DelegatedTo:    arg.DelegatedTo,
-		OwnerPublicKey: arg.OwnerPublicKey,
-		PurchaseTxHash: arg.PurchaseTxHash,
-		DelegateTxHash: arg.DelegateTxHash,
-	})
-	if err != nil {
-		return errors.Wrap(err, "Cannot add node")
-	}
-	return nil
-}
-
-func (repo *Repository) GetNodeCountByTierIndex(ctx context.Context, arg datagateway.GetNodeCountByTierIndexParams) ([]datagateway.GetNodeCountByTierIndexRow, error) {
-	nodeCount, err := repo.queries.GetNodeCountByTierIndex(ctx, gen.GetNodeCountByTierIndexParams{
-		SaleBlock:   int64(arg.SaleBlock),
-		SaleTxIndex: int32(arg.SaleTxIndex),
-		FromTier:    int32(arg.FromTier),
-		ToTier:      int32(arg.ToTier),
-	})
-	if err != nil {
-		return nil, errors.Wrap(err, "Cannot get node count by tier index")
-	}
-
-	return mapNodeCountByTierIndexRows(nodeCount), nil
-}
-
-func (repo *Repository) GetNodesByPubkey(ctx context.Context, arg datagateway.GetNodesByPubkeyParams) ([]entity.Node, error) {
-	nodes, err := repo.queries.GetNodesByPubkey(ctx, gen.GetNodesByPubkeyParams{
-		SaleBlock:      arg.SaleBlock,
-		SaleTxIndex:    arg.SaleTxIndex,
-		OwnerPublicKey: arg.OwnerPublicKey,
-		DelegatedTo:    arg.DelegatedTo,
-	})
-	if err != nil {
-		return nil, errors.Wrap(err, "Cannot get nodes by public key")
-	}
-	return mapNodes(nodes), nil
-}
-
-func (repo *Repository) GetEventsByWallet(ctx context.Context, walletAddress string) ([]entity.NodeSaleEvent, error) {
-	events, err := repo.queries.GetEventsByWallet(ctx, walletAddress)
-	if err != nil {
-		return nil, errors.Wrap(err, "cannot get events by wallet")
-	}
-	return mapNodeSalesEvents(events), nil
-}
-
-func (repo *Repository) GetNodesByDeployment(ctx context.Context, saleBlock int64, saleTxIndex int32) ([]entity.Node, error) {
-	nodes, err := repo.queries.GetNodesByDeployment(ctx, gen.GetNodesByDeploymentParams{
-		SaleBlock:   saleBlock,
-		SaleTxIndex: saleTxIndex,
-	})
-	if err != nil {
-		return nil, errors.Wrap(err, "cannot get nodes by deploy")
-	}
-	return mapNodes(nodes), nil
-}

modules/nodesale/repository/postgres/tx.go

@@ -1,62 +0,0 @@
-package postgres
-
-import (
-	"context"
-
-	"github.com/cockroachdb/errors"
-	"github.com/gaze-network/indexer-network/modules/nodesale/datagateway"
-	"github.com/gaze-network/indexer-network/pkg/logger"
-	"github.com/jackc/pgx/v5"
-)
-
-var ErrTxAlreadyExists = errors.New("Transaction already exists. Call Commit() or Rollback() first.")
-
-func (r *Repository) begin(ctx context.Context) (*Repository, error) {
-	if r.tx != nil {
-		return nil, errors.WithStack(ErrTxAlreadyExists)
-	}
-	tx, err := r.db.Begin(ctx)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to begin transaction")
-	}
-	return &Repository{
-		db:      r.db,
-		queries: r.queries.WithTx(tx),
-		tx:      tx,
-	}, nil
-}
-
-func (r *Repository) BeginNodeSaleTx(ctx context.Context) (datagateway.NodeSaleDataGatewayWithTx, error) {
-	repo, err := r.begin(ctx)
-	if err != nil {
-		return nil, errors.WithStack(err)
-	}
-	return repo, nil
-}
-
-func (r *Repository) Commit(ctx context.Context) error {
-	if r.tx == nil {
-		return nil
-	}
-	err := r.tx.Commit(ctx)
-	if err != nil {
-		return errors.Wrap(err, "failed to commit transaction")
-	}
-	r.tx = nil
-	return nil
-}
-
-func (r *Repository) Rollback(ctx context.Context) error {
-	if r.tx == nil {
-		return nil
-	}
-	err := r.tx.Rollback(ctx)
-	if err != nil && !errors.Is(err, pgx.ErrTxClosed) {
-		return errors.Wrap(err, "failed to rollback transaction")
-	}
-	if err == nil {
-		logger.DebugContext(ctx, "rolled back transaction")
-	}
-	r.tx = nil
-	return nil
-}

modules/nodesale/tapscript.go

@@ -1,25 +0,0 @@
-package nodesale
-
-import "github.com/btcsuite/btcd/txscript"
-
-func extractTapScript(witness [][]byte) (tokenizer txscript.ScriptTokenizer, controlBlock *txscript.ControlBlock, isTapScript bool) {
-	witness = removeAnnexFromWitness(witness)
-	if len(witness) < 2 {
-		return txscript.ScriptTokenizer{}, nil, false
-	}
-	script := witness[len(witness)-2]
-	rawControl := witness[len(witness)-1]
-	parsedControl, err := txscript.ParseControlBlock(rawControl)
-	if err != nil {
-		return txscript.ScriptTokenizer{}, nil, false
-	}
-
-	return txscript.MakeScriptTokenizer(0, script), parsedControl, true
-}
-
-func removeAnnexFromWitness(witness [][]byte) [][]byte {
-	if len(witness) >= 2 && len(witness[len(witness)-1]) > 0 && witness[len(witness)-1][0] == txscript.TaprootAnnexTag {
-		return witness[:len(witness)-1]
-	}
-	return witness
-}

modules/runes/api/httphandler/get_balances_by_address.go

@@ -1,49 +1,29 @@
 package httphandler
 
 import (
-	"net/url"
+	"slices"
 
 	"github.com/cockroachdb/errors"
 	"github.com/gaze-network/indexer-network/common/errs"
-	"github.com/gaze-network/indexer-network/modules/runes/internal/entity"
 	"github.com/gaze-network/indexer-network/modules/runes/runes"
 	"github.com/gaze-network/uint128"
 	"github.com/gofiber/fiber/v2"
 	"github.com/samber/lo"
 )
 
-type getBalancesRequest struct {
-	paginationRequest
+type getBalancesByAddressRequest struct {
 	Wallet      string `params:"wallet"`
 	Id          string `query:"id"`
 	BlockHeight uint64 `query:"blockHeight"`
 }
 
-const (
-	getBalancesMaxLimit     = 5000
-	getBalancesDefaultLimit = 100
-)
-
-func (r *getBalancesRequest) Validate() error {
+func (r getBalancesByAddressRequest) Validate() error {
 	var errList []error
 	if r.Wallet == "" {
 		errList = append(errList, errors.New("'wallet' is required"))
 	}
-	if r.Id != "" {
-		id, err := url.QueryUnescape(r.Id)
-		if err != nil {
-			return errors.WithStack(err)
-		}
-		r.Id = id
-		if !isRuneIdOrRuneName(r.Id) {
-			errList = append(errList, errors.Errorf("id '%s' is not valid rune id or rune name", r.Id))
-		}
-	}
-	if r.Limit < 0 {
-		errList = append(errList, errors.New("'limit' must be non-negative"))
-	}
-	if r.Limit > getBalancesMaxLimit {
-		errList = append(errList, errors.Errorf("'limit' cannot exceed %d", getBalancesMaxLimit))
+	if r.Id != "" && !isRuneIdOrRuneName(r.Id) {
+		errList = append(errList, errors.New("'id' is not valid rune id or rune name"))
 	}
 	return errs.WithPublicMessage(errors.Join(errList...), "validation error")
 }
@@ -56,15 +36,15 @@ type balance struct {
 	Decimals uint8            `json:"decimals"`
 }
 
-type getBalancesResult struct {
+type getBalancesByAddressResult struct {
 	List        []balance `json:"list"`
 	BlockHeight uint64    `json:"blockHeight"`
 }
 
-type getBalancesResponse = HttpResponse[getBalancesResult]
+type getBalancesByAddressResponse = HttpResponse[getBalancesByAddressResult]
 
-func (h *HttpHandler) GetBalances(ctx *fiber.Ctx) (err error) {
-	var req getBalancesRequest
+func (h *HttpHandler) GetBalancesByAddress(ctx *fiber.Ctx) (err error) {
+	var req getBalancesByAddressRequest
 	if err := ctx.ParamsParser(&req); err != nil {
 		return errors.WithStack(err)
 	}
@@ -74,9 +54,6 @@ func (h *HttpHandler) GetBalances(ctx *fiber.Ctx) (err error) {
 	if err := req.Validate(); err != nil {
 		return errors.WithStack(err)
 	}
-	if err := req.ParseDefault(); err != nil {
-		return errors.WithStack(err)
-	}
 
 	pkScript, ok := resolvePkScript(h.network, req.Wallet)
 	if !ok {
@@ -87,52 +64,49 @@ func (h *HttpHandler) GetBalances(ctx *fiber.Ctx) (err error) {
 	if blockHeight == 0 {
 		blockHeader, err := h.usecase.GetLatestBlock(ctx.UserContext())
 		if err != nil {
-			if errors.Is(err, errs.NotFound) {
-				return errs.NewPublicError("latest block not found")
-			}
 			return errors.Wrap(err, "error during GetLatestBlock")
 		}
 		blockHeight = uint64(blockHeader.Height)
 	}
 
-	balances, err := h.usecase.GetBalancesByPkScript(ctx.UserContext(), pkScript, blockHeight, req.Limit, req.Offset)
+	balances, err := h.usecase.GetBalancesByPkScript(ctx.UserContext(), pkScript, blockHeight)
 	if err != nil {
-		if errors.Is(err, errs.NotFound) {
-			return errs.NewPublicError("balances not found")
-		}
 		return errors.Wrap(err, "error during GetBalancesByPkScript")
 	}
 
 	runeId, ok := h.resolveRuneId(ctx.UserContext(), req.Id)
 	if ok {
 		// filter out balances that don't match the requested rune id
-		balances = lo.Filter(balances, func(b *entity.Balance, _ int) bool {
-			return b.RuneId == runeId
-		})
+		for key := range balances {
+			if key != runeId {
+				delete(balances, key)
+			}
+		}
 	}
 
-	balanceRuneIds := lo.Map(balances, func(b *entity.Balance, _ int) runes.RuneId {
-		return b.RuneId
-	})
+	balanceRuneIds := lo.Keys(balances)
 	runeEntries, err := h.usecase.GetRuneEntryByRuneIdBatch(ctx.UserContext(), balanceRuneIds)
 	if err != nil {
 		return errors.Wrap(err, "error during GetRuneEntryByRuneIdBatch")
 	}
 
 	balanceList := make([]balance, 0, len(balances))
-	for _, b := range balances {
-		runeEntry := runeEntries[b.RuneId]
+	for id, b := range balances {
+		runeEntry := runeEntries[id]
 		balanceList = append(balanceList, balance{
 			Amount:   b.Amount,
-			Id:       b.RuneId,
+			Id:       id,
 			Name:     runeEntry.SpacedRune,
 			Symbol:   string(runeEntry.Symbol),
 			Decimals: runeEntry.Divisibility,
 		})
 	}
+	slices.SortFunc(balanceList, func(i, j balance) int {
+		return j.Amount.Cmp(i.Amount)
+	})
 
-	resp := getBalancesResponse{
-		Result: &getBalancesResult{
+	resp := getBalancesByAddressResponse{
+		Result: &getBalancesByAddressResult{
 			BlockHeight: blockHeight,
 			List:        balanceList,
 		},

modules/runes/api/httphandler/get_balances_by_address_batch.go

@@ -3,11 +3,10 @@ package httphandler
 import (
 	"context"
 	"fmt"
+	"slices"
 
 	"github.com/cockroachdb/errors"
 	"github.com/gaze-network/indexer-network/common/errs"
-	"github.com/gaze-network/indexer-network/modules/runes/internal/entity"
-	"github.com/gaze-network/indexer-network/modules/runes/runes"
 	"github.com/gofiber/fiber/v2"
 	"github.com/samber/lo"
 	"golang.org/x/sync/errgroup"
@@ -17,49 +16,33 @@ type getBalanceQuery struct {
 	Wallet      string `json:"wallet"`
 	Id          string `json:"id"`
 	BlockHeight uint64 `json:"blockHeight"`
-	Limit       int32  `json:"limit"`
-	Offset      int32  `json:"offset"`
 }
 
-type getBalancesBatchRequest struct {
+type getBalancesByAddressBatchRequest struct {
 	Queries []getBalanceQuery `json:"queries"`
 }
 
-const getBalancesBatchMaxQueries = 100
-
-func (r getBalancesBatchRequest) Validate() error {
+func (r getBalancesByAddressBatchRequest) Validate() error {
 	var errList []error
-	if len(r.Queries) == 0 {
-		errList = append(errList, errors.New("at least one query is required"))
-	}
-	if len(r.Queries) > getBalancesBatchMaxQueries {
-		errList = append(errList, errors.Errorf("cannot exceed %d queries", getBalancesBatchMaxQueries))
-	}
-	for i, query := range r.Queries {
+	for _, query := range r.Queries {
 		if query.Wallet == "" {
-			errList = append(errList, errors.Errorf("queries[%d]: 'wallet' is required", i))
+			errList = append(errList, errors.Errorf("queries[%d]: 'wallet' is required"))
 		}
 		if query.Id != "" && !isRuneIdOrRuneName(query.Id) {
-			errList = append(errList, errors.Errorf("queries[%d]: id '%s' is not valid rune id or rune name", i, query.Id))
-		}
-		if query.Limit < 0 {
-			errList = append(errList, errors.Errorf("queries[%d]: 'limit' must be non-negative", i))
-		}
-		if query.Limit > getBalancesMaxLimit {
-			errList = append(errList, errors.Errorf("queries[%d]: 'limit' cannot exceed %d", i, getBalancesMaxLimit))
+			errList = append(errList, errors.Errorf("queries[%d]: 'id' is not valid rune id or rune name"))
 		}
 	}
 	return errs.WithPublicMessage(errors.Join(errList...), "validation error")
 }
 
-type getBalancesBatchResult struct {
-	List []*getBalancesResult `json:"list"`
+type getBalancesByAddressBatchResult struct {
+	List []*getBalancesByAddressResult `json:"list"`
 }
 
-type getBalancesBatchResponse = HttpResponse[getBalancesBatchResult]
+type getBalancesByAddressBatchResponse = HttpResponse[getBalancesByAddressBatchResult]
 
-func (h *HttpHandler) GetBalancesBatch(ctx *fiber.Ctx) (err error) {
-	var req getBalancesBatchRequest
+func (h *HttpHandler) GetBalancesByAddressBatch(ctx *fiber.Ctx) (err error) {
+	var req getBalancesByAddressBatchRequest
 	if err := ctx.BodyParser(&req); err != nil {
 		return errors.WithStack(err)
 	}
@@ -70,14 +53,11 @@ func (h *HttpHandler) GetBalancesBatch(ctx *fiber.Ctx) (err error) {
 	var latestBlockHeight uint64
 	blockHeader, err := h.usecase.GetLatestBlock(ctx.UserContext())
 	if err != nil {
-		if errors.Is(err, errs.NotFound) {
-			return errs.NewPublicError("latest block not found")
-		}
 		return errors.Wrap(err, "error during GetLatestBlock")
 	}
 	latestBlockHeight = uint64(blockHeader.Height)
 
-	processQuery := func(ctx context.Context, query getBalanceQuery, queryIndex int) (*getBalancesResult, error) {
+	processQuery := func(ctx context.Context, query getBalanceQuery, queryIndex int) (*getBalancesByAddressResult, error) {
 		pkScript, ok := resolvePkScript(h.network, query.Wallet)
 		if !ok {
 			return nil, errs.NewPublicError(fmt.Sprintf("unable to resolve pkscript from \"queries[%d].wallet\"", queryIndex))
@@ -88,57 +68,50 @@ func (h *HttpHandler) GetBalancesBatch(ctx *fiber.Ctx) (err error) {
 			blockHeight = latestBlockHeight
 		}
 
-		if query.Limit == 0 {
-			query.Limit = getBalancesDefaultLimit
-		}
-
-		balances, err := h.usecase.GetBalancesByPkScript(ctx, pkScript, blockHeight, query.Limit, query.Offset)
+		balances, err := h.usecase.GetBalancesByPkScript(ctx, pkScript, blockHeight)
 		if err != nil {
-			if errors.Is(err, errs.NotFound) {
-				return nil, errs.NewPublicError("balances not found")
-			}
 			return nil, errors.Wrap(err, "error during GetBalancesByPkScript")
 		}
 
 		runeId, ok := h.resolveRuneId(ctx, query.Id)
 		if ok {
 			// filter out balances that don't match the requested rune id
-			balances = lo.Filter(balances, func(b *entity.Balance, _ int) bool {
-				return b.RuneId == runeId
-			})
+			for key := range balances {
+				if key != runeId {
+					delete(balances, key)
+				}
+			}
 		}
 
-		balanceRuneIds := lo.Map(balances, func(b *entity.Balance, _ int) runes.RuneId {
-			return b.RuneId
-		})
+		balanceRuneIds := lo.Keys(balances)
 		runeEntries, err := h.usecase.GetRuneEntryByRuneIdBatch(ctx, balanceRuneIds)
 		if err != nil {
-			if errors.Is(err, errs.NotFound) {
-				return nil, errs.NewPublicError("rune not found")
-			}
 			return nil, errors.Wrap(err, "error during GetRuneEntryByRuneIdBatch")
 		}
 
 		balanceList := make([]balance, 0, len(balances))
-		for _, b := range balances {
-			runeEntry := runeEntries[b.RuneId]
+		for id, b := range balances {
+			runeEntry := runeEntries[id]
 			balanceList = append(balanceList, balance{
 				Amount:   b.Amount,
-				Id:       b.RuneId,
+				Id:       id,
 				Name:     runeEntry.SpacedRune,
 				Symbol:   string(runeEntry.Symbol),
 				Decimals: runeEntry.Divisibility,
 			})
 		}
+		slices.SortFunc(balanceList, func(i, j balance) int {
+			return j.Amount.Cmp(i.Amount)
+		})
 
-		result := getBalancesResult{
+		result := getBalancesByAddressResult{
 			BlockHeight: blockHeight,
 			List:        balanceList,
 		}
 		return &result, nil
 	}
 
-	results := make([]*getBalancesResult, len(req.Queries))
+	results := make([]*getBalancesByAddressResult, len(req.Queries))
 	eg, ectx := errgroup.WithContext(ctx.UserContext())
 	for i, query := range req.Queries {
 		i := i
@@ -156,8 +129,8 @@ func (h *HttpHandler) GetBalancesBatch(ctx *fiber.Ctx) (err error) {
 		return errors.WithStack(err)
 	}
 
-	resp := getBalancesBatchResponse{
-		Result: &getBalancesBatchResult{
+	resp := getBalancesByAddressBatchResponse{
+		Result: &getBalancesByAddressBatchResult{
 			List: results,
 		},
 	}

modules/runes/api/httphandler/get_current_block.go

@@ -1,12 +1,28 @@
 package httphandler
 
 import (
+	"github.com/Cleverse/go-utilities/utils"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/cockroachdb/errors"
+	"github.com/gaze-network/indexer-network/common"
 	"github.com/gaze-network/indexer-network/common/errs"
-	"github.com/gaze-network/indexer-network/modules/runes/constants"
+	"github.com/gaze-network/indexer-network/core/types"
 	"github.com/gofiber/fiber/v2"
 )
 
+var startingBlockHeader = map[common.Network]types.BlockHeader{
+	common.NetworkMainnet: {
+		Height:    839999,
+		Hash:      *utils.Must(chainhash.NewHashFromStr("0000000000000000000172014ba58d66455762add0512355ad651207918494ab")),
+		PrevBlock: *utils.Must(chainhash.NewHashFromStr("00000000000000000001dcce6ce7c8a45872cafd1fb04732b447a14a91832591")),
+	},
+	common.NetworkTestnet: {
+		Height:    2583200,
+		Hash:      *utils.Must(chainhash.NewHashFromStr("000000000006c5f0dfcd9e0e81f27f97a87aef82087ffe69cd3c390325bb6541")),
+		PrevBlock: *utils.Must(chainhash.NewHashFromStr("00000000000668f3bafac992f53424774515440cb47e1cb9e73af3f496139e28")),
+	},
+}
+
 type getCurrentBlockResult struct {
 	Hash   string `json:"hash"`
 	Height int64  `json:"height"`
@@ -20,7 +36,7 @@ func (h *HttpHandler) GetCurrentBlock(ctx *fiber.Ctx) (err error) {
 		if !errors.Is(err, errs.NotFound) {
 			return errors.Wrap(err, "error during GetLatestBlock")
 		}
-		blockHeader = constants.StartingBlockHeader[h.network]
+		blockHeader = startingBlockHeader[h.network]
 	}
 
 	resp := getCurrentBlockResponse{

modules/runes/api/httphandler/get_holders.go

@@ -1,15 +1,10 @@
 package httphandler
 
 import (
-	"bytes"
 	"encoding/hex"
-	"fmt"
-	"net/url"
-	"slices"
 
 	"github.com/cockroachdb/errors"
 	"github.com/gaze-network/indexer-network/common/errs"
-	"github.com/gaze-network/indexer-network/modules/runes/internal/entity"
 	"github.com/gaze-network/indexer-network/modules/runes/runes"
 	"github.com/gaze-network/uint128"
 	"github.com/gofiber/fiber/v2"
@@ -17,30 +12,14 @@ import (
 )
 
 type getHoldersRequest struct {
-	paginationRequest
 	Id          string `params:"id"`
 	BlockHeight uint64 `query:"blockHeight"`
 }
 
-const (
-	getHoldersMaxLimit = 1000
-)
-
-func (r *getHoldersRequest) Validate() error {
+func (r getHoldersRequest) Validate() error {
 	var errList []error
-	id, err := url.QueryUnescape(r.Id)
-	if err != nil {
-		return errors.WithStack(err)
-	}
-	r.Id = id
 	if !isRuneIdOrRuneName(r.Id) {
-		errList = append(errList, errors.Errorf("id '%s' is not valid rune id or rune name", r.Id))
-	}
-	if r.Limit < 0 {
-		errList = append(errList, errors.New("'limit' must be non-negative"))
-	}
-	if r.Limit > getHoldersMaxLimit {
-		errList = append(errList, errors.Errorf("'limit' cannot exceed %d", getHoldersMaxLimit))
+		errList = append(errList, errors.New("'id' is not valid rune id or rune name"))
 	}
 	return errs.WithPublicMessage(errors.Join(errList...), "validation error")
 }
@@ -56,7 +35,6 @@ type getHoldersResult struct {
 	BlockHeight  uint64           `json:"blockHeight"`
 	TotalSupply  uint128.Uint128  `json:"totalSupply"`
 	MintedAmount uint128.Uint128  `json:"mintedAmount"`
-	Decimals     uint8            `json:"decimals"`
 	List         []holdingBalance `json:"list"`
 }
 
@@ -73,9 +51,6 @@ func (h *HttpHandler) GetHolders(ctx *fiber.Ctx) (err error) {
 	if err := req.Validate(); err != nil {
 		return errors.WithStack(err)
 	}
-	if err := req.ParseDefault(); err != nil {
-		return errors.WithStack(err)
-	}
 
 	blockHeight := req.BlockHeight
 	if blockHeight == 0 {
@@ -91,22 +66,16 @@ func (h *HttpHandler) GetHolders(ctx *fiber.Ctx) (err error) {
 		var ok bool
 		runeId, ok = h.resolveRuneId(ctx.UserContext(), req.Id)
 		if !ok {
-			return errs.NewPublicError(fmt.Sprintf("unable to resolve rune id \"%s\" from \"id\"", req.Id))
+			return errs.NewPublicError("unable to resolve rune id from \"id\"")
 		}
 	}
 
 	runeEntry, err := h.usecase.GetRuneEntryByRuneIdAndHeight(ctx.UserContext(), runeId, blockHeight)
 	if err != nil {
-		if errors.Is(err, errs.NotFound) {
-			return errs.NewPublicError("rune not found")
-		}
-		return errors.Wrap(err, "error during GetRuneEntryByRuneIdAndHeight")
+		return errors.Wrap(err, "error during GetHoldersByHeight")
 	}
-	holdingBalances, err := h.usecase.GetBalancesByRuneId(ctx.UserContext(), runeId, blockHeight, req.Limit, req.Offset)
+	holdingBalances, err := h.usecase.GetBalancesByRuneId(ctx.UserContext(), runeId, blockHeight)
 	if err != nil {
-		if errors.Is(err, errs.NotFound) {
-			return errs.NewPublicError("balances not found")
-		}
 		return errors.Wrap(err, "error during GetBalancesByRuneId")
 	}
 
@@ -132,20 +101,11 @@ func (h *HttpHandler) GetHolders(ctx *fiber.Ctx) (err error) {
 		})
 	}
 
-	// sort by amount descending, then pk script ascending
-	slices.SortFunc(holdingBalances, func(b1, b2 *entity.Balance) int {
-		if b1.Amount.Cmp(b2.Amount) == 0 {
-			return bytes.Compare(b1.PkScript, b2.PkScript)
-		}
-		return b2.Amount.Cmp(b1.Amount)
-	})
-
 	resp := getHoldersResponse{
 		Result: &getHoldersResult{
 			BlockHeight:  blockHeight,
 			TotalSupply:  totalSupply,
 			MintedAmount: mintedAmount,
-			Decimals:     runeEntry.Divisibility,
 			List:         list,
 		},
 	}

modules/runes/api/httphandler/get_token_info.go

@@ -1,12 +1,11 @@
 package httphandler
 
 import (
-	"fmt"
-	"net/url"
-	"strings"
+	"slices"
 
 	"github.com/cockroachdb/errors"
 	"github.com/gaze-network/indexer-network/common/errs"
+	"github.com/gaze-network/indexer-network/modules/runes/internal/entity"
 	"github.com/gaze-network/indexer-network/modules/runes/runes"
 	"github.com/gaze-network/uint128"
 	"github.com/gofiber/fiber/v2"
@@ -14,29 +13,15 @@ import (
 )
 
 type getTokenInfoRequest struct {
-	Id                  string `params:"id"`
-	BlockHeight         uint64 `query:"blockHeight"`
-	AdditionalFieldsRaw string `query:"additionalFields"` // comma-separated list of additional fields
-	AdditionalFields    []string
+	Id          string `params:"id"`
+	BlockHeight uint64 `query:"blockHeight"`
 }
 
-func (r *getTokenInfoRequest) Validate() error {
+func (r getTokenInfoRequest) Validate() error {
 	var errList []error
-	id, err := url.QueryUnescape(r.Id)
-	if err != nil {
-		return errors.WithStack(err)
-	}
-	r.Id = id
 	if !isRuneIdOrRuneName(r.Id) {
-		errList = append(errList, errors.Errorf("id '%s' is not valid rune id or rune name", r.Id))
+		errList = append(errList, errors.New("'id' is not valid rune id or rune name"))
 	}
-
-	if r.AdditionalFieldsRaw == "" {
-		// temporarily set default value for backward compatibility
-		r.AdditionalFieldsRaw = "holdersCount" // TODO: remove this default value after all clients are updated
-	}
-	r.AdditionalFields = strings.Split(r.AdditionalFieldsRaw, ",")
-
 	return errs.WithPublicMessage(errors.Join(errList...), "validation error")
 }
 
@@ -50,19 +35,17 @@ type entryTerms struct {
 }
 
 type entry struct {
-	Divisibility  uint8           `json:"divisibility"`
-	Premine       uint128.Uint128 `json:"premine"`
-	Rune          runes.Rune      `json:"rune"`
-	Spacers       uint32          `json:"spacers"`
-	Symbol        string          `json:"symbol"`
-	Terms         entryTerms      `json:"terms"`
-	Turbo         bool            `json:"turbo"`
-	EtchingTxHash string          `json:"etchingTxHash"`
+	Divisibility uint8           `json:"divisibility"`
+	Premine      uint128.Uint128 `json:"premine"`
+	Rune         runes.Rune      `json:"rune"`
+	Spacers      uint32          `json:"spacers"`
+	Symbol       string          `json:"symbol"`
+	Terms        entryTerms      `json:"terms"`
+	Turbo        bool            `json:"turbo"`
 }
 
 type tokenInfoExtend struct {
-	HoldersCount *int64 `json:"holdersCount,omitempty"`
-	Entry        entry  `json:"entry"`
+	Entry entry `json:"entry"`
 }
 
 type getTokenInfoResult struct {
@@ -74,11 +57,11 @@ type getTokenInfoResult struct {
 	MintedAmount      uint128.Uint128  `json:"mintedAmount"`
 	BurnedAmount      uint128.Uint128  `json:"burnedAmount"`
 	Decimals          uint8            `json:"decimals"`
-	DeployedAt        int64            `json:"deployedAt"` // unix timestamp
+	DeployedAt        uint64           `json:"deployedAt"` // unix timestamp
 	DeployedAtHeight  uint64           `json:"deployedAtHeight"`
-	CompletedAt       *int64           `json:"completedAt"` // unix timestamp
+	CompletedAt       *uint64          `json:"completedAt"` // unix timestamp
 	CompletedAtHeight *uint64          `json:"completedAtHeight"`
-	HoldersCount      int64            `json:"holdersCount"` // deprecated // TODO: remove later
+	HoldersCount      int              `json:"holdersCount"`
 	Extend            tokenInfoExtend  `json:"extend"`
 }
 
@@ -100,9 +83,6 @@ func (h *HttpHandler) GetTokenInfo(ctx *fiber.Ctx) (err error) {
 	if blockHeight == 0 {
 		blockHeader, err := h.usecase.GetLatestBlock(ctx.UserContext())
 		if err != nil {
-			if errors.Is(err, errs.NotFound) {
-				return errs.NewPublicError("latest block not found")
-			}
 			return errors.Wrap(err, "error during GetLatestBlock")
 		}
 		blockHeight = uint64(blockHeader.Height)
@@ -113,87 +93,73 @@ func (h *HttpHandler) GetTokenInfo(ctx *fiber.Ctx) (err error) {
 		var ok bool
 		runeId, ok = h.resolveRuneId(ctx.UserContext(), req.Id)
 		if !ok {
-			return errs.NewPublicError(fmt.Sprintf("unable to resolve rune id \"%s\" from \"id\"", req.Id))
+			return errs.NewPublicError("unable to resolve rune id from \"id\"")
 		}
 	}
 
 	runeEntry, err := h.usecase.GetRuneEntryByRuneIdAndHeight(ctx.UserContext(), runeId, blockHeight)
 	if err != nil {
-		if errors.Is(err, errs.NotFound) {
-			return errs.NewPublicError("rune not found")
-		}
-		return errors.Wrap(err, "error during GetRuneEntryByRuneIdAndHeight")
+		return errors.Wrap(err, "error during GetTokenInfoByHeight")
 	}
-	var holdersCountPtr *int64
-	if lo.Contains(req.AdditionalFields, "holdersCount") {
-		holdersCount, err := h.usecase.GetTotalHoldersByRuneId(ctx.UserContext(), runeId, blockHeight)
-		if err != nil {
-			if errors.Is(err, errs.NotFound) {
-				return errs.NewPublicError("rune not found")
-			}
-			return errors.Wrap(err, "error during GetBalancesByRuneId")
-		}
-		holdersCountPtr = &holdersCount
-	}
-
-	result, err := createTokenInfoResult(runeEntry, holdersCountPtr)
+	holdingBalances, err := h.usecase.GetBalancesByRuneId(ctx.UserContext(), runeId, blockHeight)
 	if err != nil {
-		return errors.Wrap(err, "error during createTokenInfoResult")
+		return errors.Wrap(err, "error during GetBalancesByRuneId")
 	}
 
-	resp := getTokenInfoResponse{
-		Result: result,
-	}
+	holdingBalances = lo.Filter(holdingBalances, func(b *entity.Balance, _ int) bool {
+		return !b.Amount.IsZero()
+	})
+	// sort by amount descending
+	slices.SortFunc(holdingBalances, func(i, j *entity.Balance) int {
+		return j.Amount.Cmp(i.Amount)
+	})
 
-	return errors.WithStack(ctx.JSON(resp))
-}
-
-func createTokenInfoResult(runeEntry *runes.RuneEntry, holdersCount *int64) (*getTokenInfoResult, error) {
 	totalSupply, err := runeEntry.Supply()
 	if err != nil {
-		return nil, errors.Wrap(err, "cannot get total supply of rune")
+		return errors.Wrap(err, "cannot get total supply of rune")
 	}
 	mintedAmount, err := runeEntry.MintedAmount()
 	if err != nil {
-		return nil, errors.Wrap(err, "cannot get minted amount of rune")
+		return errors.Wrap(err, "cannot get minted amount of rune")
 	}
 	circulatingSupply := mintedAmount.Sub(runeEntry.BurnedAmount)
 
 	terms := lo.FromPtr(runeEntry.Terms)
-
-	return &getTokenInfoResult{
-		Id:                runeEntry.RuneId,
-		Name:              runeEntry.SpacedRune,
-		Symbol:            string(runeEntry.Symbol),
-		TotalSupply:       totalSupply,
-		CirculatingSupply: circulatingSupply,
-		MintedAmount:      mintedAmount,
-		BurnedAmount:      runeEntry.BurnedAmount,
-		Decimals:          runeEntry.Divisibility,
-		DeployedAt:        runeEntry.EtchedAt.Unix(),
-		DeployedAtHeight:  runeEntry.EtchingBlock,
-		CompletedAt:       lo.Ternary(runeEntry.CompletedAt.IsZero(), nil, lo.ToPtr(runeEntry.CompletedAt.Unix())),
-		CompletedAtHeight: runeEntry.CompletedAtHeight,
-		HoldersCount:      lo.FromPtr(holdersCount),
-		Extend: tokenInfoExtend{
-			HoldersCount: holdersCount,
-			Entry: entry{
-				Divisibility: runeEntry.Divisibility,
-				Premine:      runeEntry.Premine,
-				Rune:         runeEntry.SpacedRune.Rune,
-				Spacers:      runeEntry.SpacedRune.Spacers,
-				Symbol:       string(runeEntry.Symbol),
-				Terms: entryTerms{
-					Amount:      lo.FromPtr(terms.Amount),
-					Cap:         lo.FromPtr(terms.Cap),
-					HeightStart: terms.HeightStart,
-					HeightEnd:   terms.HeightEnd,
-					OffsetStart: terms.OffsetStart,
-					OffsetEnd:   terms.OffsetEnd,
+	resp := getTokenInfoResponse{
+		Result: &getTokenInfoResult{
+			Id:                runeId,
+			Name:              runeEntry.SpacedRune,
+			Symbol:            string(runeEntry.Symbol),
+			TotalSupply:       totalSupply,
+			CirculatingSupply: circulatingSupply,
+			MintedAmount:      mintedAmount,
+			BurnedAmount:      runeEntry.BurnedAmount,
+			Decimals:          runeEntry.Divisibility,
+			DeployedAt:        uint64(runeEntry.EtchedAt.Unix()),
+			DeployedAtHeight:  runeEntry.EtchingBlock,
+			CompletedAt:       lo.Ternary(runeEntry.CompletedAt.IsZero(), nil, lo.ToPtr(uint64(runeEntry.CompletedAt.Unix()))),
+			CompletedAtHeight: runeEntry.CompletedAtHeight,
+			HoldersCount:      len(holdingBalances),
+			Extend: tokenInfoExtend{
+				Entry: entry{
+					Divisibility: runeEntry.Divisibility,
+					Premine:      runeEntry.Premine,
+					Rune:         runeEntry.SpacedRune.Rune,
+					Spacers:      runeEntry.SpacedRune.Spacers,
+					Symbol:       string(runeEntry.Symbol),
+					Terms: entryTerms{
+						Amount:      lo.FromPtr(terms.Amount),
+						Cap:         lo.FromPtr(terms.Cap),
+						HeightStart: terms.HeightStart,
+						HeightEnd:   terms.HeightEnd,
+						OffsetStart: terms.OffsetStart,
+						OffsetEnd:   terms.OffsetEnd,
+					},
+					Turbo: runeEntry.Turbo,
 				},
-				Turbo:         runeEntry.Turbo,
-				EtchingTxHash: runeEntry.EtchingTxHash.String(),
 			},
 		},
-	}, nil
+	}
+
+	return errors.WithStack(ctx.JSON(resp))
 }

modules/runes/api/httphandler/get_token_info_batch.go

@@ -1,118 +0,0 @@
-package httphandler
-
-import (
-	"fmt"
-	"net/url"
-
-	"github.com/cockroachdb/errors"
-	"github.com/gaze-network/indexer-network/common/errs"
-	"github.com/gaze-network/indexer-network/modules/runes/runes"
-	"github.com/gofiber/fiber/v2"
-	"github.com/samber/lo"
-)
-
-type getTokenInfoBatchRequest struct {
-	Ids              []string `json:"ids"`
-	BlockHeight      uint64   `json:"blockHeight"`
-	AdditionalFields []string `json:"additionalFields"`
-}
-
-const getTokenInfoBatchMaxQueries = 100
-
-func (r *getTokenInfoBatchRequest) Validate() error {
-	var errList []error
-
-	if len(r.Ids) == 0 {
-		errList = append(errList, errors.New("ids cannot be empty"))
-	}
-	if len(r.Ids) > getTokenInfoBatchMaxQueries {
-		errList = append(errList, errors.Errorf("cannot query more than %d ids", getTokenInfoBatchMaxQueries))
-	}
-	for i := range r.Ids {
-		id, err := url.QueryUnescape(r.Ids[i])
-		if err != nil {
-			return errors.WithStack(err)
-		}
-		r.Ids[i] = id
-		if !isRuneIdOrRuneName(r.Ids[i]) {
-			errList = append(errList, errors.Errorf("ids[%d]: id '%s' is not valid rune id or rune name", i, r.Ids[i]))
-		}
-	}
-
-	return errs.WithPublicMessage(errors.Join(errList...), "validation error")
-}
-
-type getTokenInfoBatchResult struct {
-	List []*getTokenInfoResult `json:"list"`
-}
-type getTokenInfoBatchResponse = HttpResponse[getTokenInfoBatchResult]
-
-func (h *HttpHandler) GetTokenInfoBatch(ctx *fiber.Ctx) (err error) {
-	var req getTokenInfoBatchRequest
-	if err := ctx.BodyParser(&req); err != nil {
-		return errors.WithStack(err)
-	}
-	if err := req.Validate(); err != nil {
-		return errors.WithStack(err)
-	}
-
-	blockHeight := req.BlockHeight
-	if blockHeight == 0 {
-		blockHeader, err := h.usecase.GetLatestBlock(ctx.UserContext())
-		if err != nil {
-			if errors.Is(err, errs.NotFound) {
-				return errs.NewPublicError("latest block not found")
-			}
-			return errors.Wrap(err, "error during GetLatestBlock")
-		}
-		blockHeight = uint64(blockHeader.Height)
-	}
-
-	runeIds := make([]runes.RuneId, 0)
-	for i, id := range req.Ids {
-		runeId, ok := h.resolveRuneId(ctx.UserContext(), id)
-		if !ok {
-			return errs.NewPublicError(fmt.Sprintf("unable to resolve rune id \"%s\" from \"ids[%d]\"", id, i))
-		}
-		runeIds = append(runeIds, runeId)
-	}
-
-	runeEntries, err := h.usecase.GetRuneEntryByRuneIdAndHeightBatch(ctx.UserContext(), runeIds, blockHeight)
-	if err != nil {
-		return errors.Wrap(err, "error during GetRuneEntryByRuneIdAndHeightBatch")
-	}
-	holdersCounts := make(map[runes.RuneId]int64)
-	if lo.Contains(req.AdditionalFields, "holdersCount") {
-		holdersCounts, err = h.usecase.GetTotalHoldersByRuneIds(ctx.UserContext(), runeIds, blockHeight)
-		if err != nil {
-			return errors.Wrap(err, "error during GetBalancesByRuneId")
-		}
-	}
-
-	results := make([]*getTokenInfoResult, 0, len(runeIds))
-
-	for _, runeId := range runeIds {
-		runeEntry, ok := runeEntries[runeId]
-		if !ok {
-			return errs.NewPublicError(fmt.Sprintf("rune not found: %s", runeId))
-		}
-		var holdersCount *int64
-		if lo.Contains(req.AdditionalFields, "holdersCount") {
-			holdersCount = lo.ToPtr(holdersCounts[runeId])
-		}
-
-		result, err := createTokenInfoResult(runeEntry, holdersCount)
-		if err != nil {
-			return errors.Wrap(err, "error during createTokenInfoResult")
-		}
-		results = append(results, result)
-	}
-
-	resp := getTokenInfoBatchResponse{
-		Result: &getTokenInfoBatchResult{
-			List: results,
-		},
-	}
-
-	return errors.WithStack(ctx.JSON(resp))
-}

modules/runes/api/httphandler/get_tokens.go

@@ -1,150 +0,0 @@
-package httphandler
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/cockroachdb/errors"
-	"github.com/gaze-network/indexer-network/common/errs"
-	"github.com/gaze-network/indexer-network/modules/runes/runes"
-	"github.com/gofiber/fiber/v2"
-	"github.com/samber/lo"
-)
-
-const (
-	getTokensMaxLimit = 1000
-)
-
-type GetTokensScope string
-
-const (
-	GetTokensScopeAll     GetTokensScope = "all"
-	GetTokensScopeOngoing GetTokensScope = "ongoing"
-)
-
-func (s GetTokensScope) IsValid() bool {
-	switch s {
-	case GetTokensScopeAll, GetTokensScopeOngoing:
-		return true
-	}
-	return false
-}
-
-type getTokensRequest struct {
-	paginationRequest
-	Search              string         `query:"search"`
-	BlockHeight         uint64         `query:"blockHeight"`
-	Scope               GetTokensScope `query:"scope"`
-	AdditionalFieldsRaw string         `query:"additionalFields"` // comma-separated list of additional fields
-	AdditionalFields    []string
-}
-
-func (r *getTokensRequest) Validate() error {
-	var errList []error
-	if err := r.paginationRequest.Validate(); err != nil {
-		errList = append(errList, err)
-	}
-	if r.Limit > getTokensMaxLimit {
-		errList = append(errList, errors.Errorf("limit must be less than or equal to 1000"))
-	}
-	if r.Scope != "" && !r.Scope.IsValid() {
-		errList = append(errList, errors.Errorf("invalid scope: %s", r.Scope))
-	}
-
-	if r.AdditionalFieldsRaw == "" {
-		// temporarily set default value for backward compatibility
-		r.AdditionalFieldsRaw = "holdersCount" // TODO: remove this default value after all clients are updated
-	}
-	r.AdditionalFields = strings.Split(r.AdditionalFieldsRaw, ",")
-
-	return errs.WithPublicMessage(errors.Join(errList...), "validation error")
-}
-
-func (req *getTokensRequest) ParseDefault() error {
-	if err := req.paginationRequest.ParseDefault(); err != nil {
-		return errors.WithStack(err)
-	}
-	if req.Scope == "" {
-		req.Scope = GetTokensScopeAll
-	}
-	return nil
-}
-
-type getTokensResult struct {
-	List []*getTokenInfoResult `json:"list"`
-}
-
-type getTokensResponse = HttpResponse[getTokensResult]
-
-func (h *HttpHandler) GetTokens(ctx *fiber.Ctx) (err error) {
-	var req getTokensRequest
-	if err := ctx.QueryParser(&req); err != nil {
-		return errors.WithStack(err)
-	}
-	if err := req.Validate(); err != nil {
-		return errors.WithStack(err)
-	}
-	if err := req.ParseDefault(); err != nil {
-		return errors.WithStack(err)
-	}
-
-	blockHeight := req.BlockHeight
-	if blockHeight == 0 {
-		blockHeader, err := h.usecase.GetLatestBlock(ctx.UserContext())
-		if err != nil {
-			if errors.Is(err, errs.NotFound) {
-				return errs.NewPublicError("latest block not found")
-			}
-			return errors.Wrap(err, "error during GetLatestBlock")
-		}
-		blockHeight = uint64(blockHeader.Height)
-	}
-
-	// remove spacers
-	search := strings.Replace(strings.Replace(req.Search, "•", "", -1), ".", "", -1)
-
-	var entries []*runes.RuneEntry
-	switch req.Scope {
-	case GetTokensScopeAll:
-		entries, err = h.usecase.GetRuneEntries(ctx.UserContext(), search, blockHeight, req.Limit, req.Offset)
-		if err != nil {
-			return errors.Wrap(err, "error during GetRuneEntryList")
-		}
-	case GetTokensScopeOngoing:
-		entries, err = h.usecase.GetOngoingRuneEntries(ctx.UserContext(), search, blockHeight, req.Limit, req.Offset)
-		if err != nil {
-			return errors.Wrap(err, "error during GetRuneEntryList")
-		}
-	default:
-		return errs.NewPublicError(fmt.Sprintf("invalid scope: %s", req.Scope))
-	}
-
-	runeIds := lo.Map(entries, func(item *runes.RuneEntry, _ int) runes.RuneId { return item.RuneId })
-	holdersCounts := make(map[runes.RuneId]int64)
-	if lo.Contains(req.AdditionalFields, "holdersCount") {
-		holdersCounts, err = h.usecase.GetTotalHoldersByRuneIds(ctx.UserContext(), runeIds, blockHeight)
-		if err != nil {
-			return errors.Wrap(err, "error during GetTotalHoldersByRuneIds")
-		}
-	}
-
-	results := make([]*getTokenInfoResult, 0, len(entries))
-	for _, ent := range entries {
-		var holdersCount *int64
-		if lo.Contains(req.AdditionalFields, "holdersCount") {
-			holdersCount = lo.ToPtr(holdersCounts[ent.RuneId])
-		}
-		result, err := createTokenInfoResult(ent, holdersCount)
-		if err != nil {
-			return errors.Wrap(err, "error during createTokenInfoResult")
-		}
-
-		results = append(results, result)
-	}
-
-	return errors.WithStack(ctx.JSON(getTokensResponse{
-		Result: &getTokensResult{
-			List: results,
-		},
-	}))
-}

modules/runes/api/httphandler/get_transaction_by_hash.go

@@ -1,171 +0,0 @@
-package httphandler
-
-import (
-	"encoding/hex"
-	"fmt"
-
-	"github.com/btcsuite/btcd/chaincfg/chainhash"
-	"github.com/cockroachdb/errors"
-	"github.com/gaze-network/indexer-network/common/errs"
-	"github.com/gaze-network/indexer-network/modules/runes/runes"
-	"github.com/gofiber/fiber/v2"
-	"github.com/samber/lo"
-)
-
-type getTransactionByHashRequest struct {
-	Hash string `params:"hash"`
-}
-
-func (r getTransactionByHashRequest) Validate() error {
-	var errList []error
-	if len(r.Hash) == 0 {
-		errList = append(errList, errs.NewPublicError("hash is required"))
-	}
-	if len(r.Hash) > chainhash.MaxHashStringSize {
-		errList = append(errList, errs.NewPublicError(fmt.Sprintf("hash length must be less than or equal to %d bytes", chainhash.MaxHashStringSize)))
-	}
-	if len(errList) == 0 {
-		return nil
-	}
-	return errs.WithPublicMessage(errors.Join(errList...), "validation error")
-}
-
-type getTransactionByHashResponse = HttpResponse[transaction]
-
-func (h *HttpHandler) GetTransactionByHash(ctx *fiber.Ctx) (err error) {
-	var req getTransactionByHashRequest
-	if err := ctx.ParamsParser(&req); err != nil {
-		return errors.WithStack(err)
-	}
-	if err := req.Validate(); err != nil {
-		return errors.WithStack(err)
-	}
-
-	hash, err := chainhash.NewHashFromStr(req.Hash)
-	if err != nil {
-		return errs.NewPublicError("invalid transaction hash")
-	}
-
-	tx, err := h.usecase.GetRuneTransaction(ctx.UserContext(), *hash)
-	if err != nil {
-		if errors.Is(err, errs.NotFound) {
-			return fiber.NewError(fiber.StatusNotFound, "transaction not found")
-		}
-		return errors.Wrap(err, "error during GetRuneTransaction")
-	}
-
-	allRuneIds := make(map[runes.RuneId]struct{})
-	for id := range tx.Mints {
-		allRuneIds[id] = struct{}{}
-	}
-	for id := range tx.Burns {
-		allRuneIds[id] = struct{}{}
-	}
-	for _, input := range tx.Inputs {
-		allRuneIds[input.RuneId] = struct{}{}
-	}
-	for _, output := range tx.Outputs {
-		allRuneIds[output.RuneId] = struct{}{}
-	}
-
-	runeEntries, err := h.usecase.GetRuneEntryByRuneIdBatch(ctx.UserContext(), lo.Keys(allRuneIds))
-	if err != nil {
-		return errors.Wrap(err, "error during GetRuneEntryByRuneIdBatch")
-	}
-
-	respTx := &transaction{
-		TxHash:      tx.Hash,
-		BlockHeight: tx.BlockHeight,
-		Index:       tx.Index,
-		Timestamp:   tx.Timestamp.Unix(),
-		Inputs:      make([]txInputOutput, 0, len(tx.Inputs)),
-		Outputs:     make([]txInputOutput, 0, len(tx.Outputs)),
-		Mints:       make(map[string]amountWithDecimal, len(tx.Mints)),
-		Burns:       make(map[string]amountWithDecimal, len(tx.Burns)),
-		Extend: runeTransactionExtend{
-			RuneEtched: tx.RuneEtched,
-			Runestone:  nil,
-		},
-	}
-	for _, input := range tx.Inputs {
-		address := addressFromPkScript(input.PkScript, h.network)
-		respTx.Inputs = append(respTx.Inputs, txInputOutput{
-			PkScript: hex.EncodeToString(input.PkScript),
-			Address:  address,
-			Id:       input.RuneId,
-			Amount:   input.Amount,
-			Decimals: runeEntries[input.RuneId].Divisibility,
-			Index:    input.Index,
-		})
-	}
-	for _, output := range tx.Outputs {
-		address := addressFromPkScript(output.PkScript, h.network)
-		respTx.Outputs = append(respTx.Outputs, txInputOutput{
-			PkScript: hex.EncodeToString(output.PkScript),
-			Address:  address,
-			Id:       output.RuneId,
-			Amount:   output.Amount,
-			Decimals: runeEntries[output.RuneId].Divisibility,
-			Index:    output.Index,
-		})
-	}
-	for id, amount := range tx.Mints {
-		respTx.Mints[id.String()] = amountWithDecimal{
-			Amount:   amount,
-			Decimals: runeEntries[id].Divisibility,
-		}
-	}
-	for id, amount := range tx.Burns {
-		respTx.Burns[id.String()] = amountWithDecimal{
-			Amount:   amount,
-			Decimals: runeEntries[id].Divisibility,
-		}
-	}
-	if tx.Runestone != nil {
-		var e *etching
-		if tx.Runestone.Etching != nil {
-			var symbol *string
-			if tx.Runestone.Etching.Symbol != nil {
-				symbol = lo.ToPtr(string(*tx.Runestone.Etching.Symbol))
-			}
-			var t *terms
-			if tx.Runestone.Etching.Terms != nil {
-				t = &terms{
-					Amount:      tx.Runestone.Etching.Terms.Amount,
-					Cap:         tx.Runestone.Etching.Terms.Cap,
-					HeightStart: tx.Runestone.Etching.Terms.HeightStart,
-					HeightEnd:   tx.Runestone.Etching.Terms.HeightEnd,
-					OffsetStart: tx.Runestone.Etching.Terms.OffsetStart,
-					OffsetEnd:   tx.Runestone.Etching.Terms.OffsetEnd,
-				}
-			}
-			e = &etching{
-				Divisibility: tx.Runestone.Etching.Divisibility,
-				Premine:      tx.Runestone.Etching.Premine,
-				Rune:         tx.Runestone.Etching.Rune,
-				Spacers:      tx.Runestone.Etching.Spacers,
-				Symbol:       symbol,
-				Terms:        t,
-				Turbo:        tx.Runestone.Etching.Turbo,
-			}
-		}
-		respTx.Extend.Runestone = &runestone{
-			Cenotaph: tx.Runestone.Cenotaph,
-			Flaws:    lo.Ternary(tx.Runestone.Cenotaph, tx.Runestone.Flaws.CollectAsString(), nil),
-			Etching:  e,
-			Edicts: lo.Map(tx.Runestone.Edicts, func(ed runes.Edict, _ int) edict {
-				return edict{
-					Id:     ed.Id,
-					Amount: ed.Amount,
-					Output: ed.Output,
-				}
-			}),
-			Mint:    tx.Runestone.Mint,
-			Pointer: tx.Runestone.Pointer,
-		}
-	}
-
-	return errors.WithStack(ctx.JSON(getTransactionByHashResponse{
-		Result: respTx,
-	}))
-}

modules/runes/api/httphandler/get_transactions.go

@@ -1,10 +1,7 @@
 package httphandler
 
 import (
-	"cmp"
 	"encoding/hex"
-	"fmt"
-	"net/url"
 	"slices"
 
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
@@ -17,40 +14,15 @@ import (
 )
 
 type getTransactionsRequest struct {
-	paginationRequest
-	Wallet    string `query:"wallet"`
-	Id        string `query:"id"`
-	FromBlock int64  `query:"fromBlock"`
-	ToBlock   int64  `query:"toBlock"`
+	Wallet      string `query:"wallet"`
+	Id          string `query:"id"`
+	BlockHeight uint64 `query:"blockHeight"`
 }
 
-const (
-	getTransactionsMaxLimit = 3000
-)
-
-func (r *getTransactionsRequest) Validate() error {
+func (r getTransactionsRequest) Validate() error {
 	var errList []error
-	if r.Id != "" {
-		id, err := url.QueryUnescape(r.Id)
-		if err != nil {
-			return errors.WithStack(err)
-		}
-		r.Id = id
-		if !isRuneIdOrRuneName(r.Id) {
-			errList = append(errList, errors.Errorf("id '%s' is not valid rune id or rune name", r.Id))
-		}
-	}
-	if r.FromBlock < -1 {
-		errList = append(errList, errors.Errorf("invalid fromBlock range"))
-	}
-	if r.ToBlock < -1 {
-		errList = append(errList, errors.Errorf("invalid toBlock range"))
-	}
-	if r.Limit < 0 {
-		errList = append(errList, errors.New("'limit' must be non-negative"))
-	}
-	if r.Limit > getTransactionsMaxLimit {
-		errList = append(errList, errors.Errorf("'limit' cannot exceed %d", getTransactionsMaxLimit))
+	if r.Id != "" && !isRuneIdOrRuneName(r.Id) {
+		errList = append(errList, errors.New("'id' is not valid rune id or rune name"))
 	}
 	return errs.WithPublicMessage(errors.Join(errList...), "validation error")
 }
@@ -134,9 +106,6 @@ func (h *HttpHandler) GetTransactions(ctx *fiber.Ctx) (err error) {
 	if err := req.Validate(); err != nil {
 		return errors.WithStack(err)
 	}
-	if err := req.ParseDefault(); err != nil {
-		return errors.WithStack(err)
-	}
 
 	var pkScript []byte
 	if req.Wallet != "" {
@@ -152,65 +121,43 @@ func (h *HttpHandler) GetTransactions(ctx *fiber.Ctx) (err error) {
 		var ok bool
 		runeId, ok = h.resolveRuneId(ctx.UserContext(), req.Id)
 		if !ok {
-			return errs.NewPublicError(fmt.Sprintf("unable to resolve rune id \"%s\" from \"id\"", req.Id))
+			return errs.NewPublicError("unable to resolve rune id from \"id\"")
 		}
 	}
 
-	// default to latest block
-	if req.ToBlock == 0 {
-		req.ToBlock = -1
-	}
-
-	// get latest block height if block height is -1
-	if req.FromBlock == -1 || req.ToBlock == -1 {
+	blockHeight := req.BlockHeight
+	// set blockHeight to the latest block height blockHeight, pkScript, and runeId are not provided
+	if blockHeight == 0 && pkScript == nil && runeId == (runes.RuneId{}) {
 		blockHeader, err := h.usecase.GetLatestBlock(ctx.UserContext())
 		if err != nil {
-			if errors.Is(err, errs.NotFound) {
-				return errs.NewPublicError("latest block not found")
-			}
 			return errors.Wrap(err, "error during GetLatestBlock")
 		}
-		if req.FromBlock == -1 {
-			req.FromBlock = blockHeader.Height
-		}
-		if req.ToBlock == -1 {
-			req.ToBlock = blockHeader.Height
-		}
+		blockHeight = uint64(blockHeader.Height)
 	}
 
-	// validate block height range
-	if req.FromBlock > req.ToBlock {
-		return errs.NewPublicError(fmt.Sprintf("fromBlock must be less than or equal to toBlock, got fromBlock=%d, toBlock=%d", req.FromBlock, req.ToBlock))
-	}
-
-	txs, err := h.usecase.GetRuneTransactions(ctx.UserContext(), pkScript, runeId, uint64(req.FromBlock), uint64(req.ToBlock), req.Limit, req.Offset)
+	txs, err := h.usecase.GetRuneTransactions(ctx.UserContext(), pkScript, runeId, blockHeight)
 	if err != nil {
-		if errors.Is(err, errs.NotFound) {
-			return errs.NewPublicError("transactions not found")
-		}
 		return errors.Wrap(err, "error during GetRuneTransactions")
 	}
 
-	allRuneIds := make(map[runes.RuneId]struct{})
+	var allRuneIds []runes.RuneId
 	for _, tx := range txs {
 		for id := range tx.Mints {
-			allRuneIds[id] = struct{}{}
+			allRuneIds = append(allRuneIds, id)
 		}
 		for id := range tx.Burns {
-			allRuneIds[id] = struct{}{}
+			allRuneIds = append(allRuneIds, id)
 		}
 		for _, input := range tx.Inputs {
-			allRuneIds[input.RuneId] = struct{}{}
+			allRuneIds = append(allRuneIds, input.RuneId)
 		}
 		for _, output := range tx.Outputs {
-			allRuneIds[output.RuneId] = struct{}{}
+			allRuneIds = append(allRuneIds, output.RuneId)
 		}
 	}
-	runeEntries, err := h.usecase.GetRuneEntryByRuneIdBatch(ctx.UserContext(), lo.Keys(allRuneIds))
+	allRuneIds = lo.Uniq(allRuneIds)
+	runeEntries, err := h.usecase.GetRuneEntryByRuneIdBatch(ctx.UserContext(), allRuneIds)
 	if err != nil {
-		if errors.Is(err, errs.NotFound) {
-			return errs.NewPublicError("rune entries not found")
-		}
 		return errors.Wrap(err, "error during GetRuneEntryByRuneIdBatch")
 	}
 
@@ -309,12 +256,12 @@ func (h *HttpHandler) GetTransactions(ctx *fiber.Ctx) (err error) {
 		}
 		txList = append(txList, respTx)
 	}
-	// sort by block height DESC, then index DESC
+	// sort by block height ASC, then index ASC
 	slices.SortFunc(txList, func(t1, t2 transaction) int {
 		if t1.BlockHeight != t2.BlockHeight {
-			return cmp.Compare(t2.BlockHeight, t1.BlockHeight)
+			return int(t1.BlockHeight - t2.BlockHeight)
 		}
-		return cmp.Compare(t2.Index, t1.Index)
+		return int(t1.Index - t2.Index)
 	})
 
 	resp := getTransactionsResponse{

modules/runes/api/httphandler/get_utxos_by_address.go

@@ -1,9 +1,8 @@
 package httphandler
 
 import (
-	"net/url"
-
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/wire"
 	"github.com/cockroachdb/errors"
 	"github.com/gaze-network/indexer-network/common/errs"
 	"github.com/gaze-network/indexer-network/modules/runes/internal/entity"
@@ -13,37 +12,19 @@ import (
 	"github.com/samber/lo"
 )
 
-type getUTXOsRequest struct {
-	paginationRequest
+type getUTXOsByAddressRequest struct {
 	Wallet      string `params:"wallet"`
 	Id          string `query:"id"`
 	BlockHeight uint64 `query:"blockHeight"`
 }
 
-const (
-	getUTXOsMaxLimit = 3000
-)
-
-func (r *getUTXOsRequest) Validate() error {
+func (r getUTXOsByAddressRequest) Validate() error {
 	var errList []error
 	if r.Wallet == "" {
 		errList = append(errList, errors.New("'wallet' is required"))
 	}
-	if r.Id != "" {
-		id, err := url.QueryUnescape(r.Id)
-		if err != nil {
-			return errors.WithStack(err)
-		}
-		r.Id = id
-		if !isRuneIdOrRuneName(r.Id) {
-			errList = append(errList, errors.Errorf("id '%s' is not valid rune id or rune name", r.Id))
-		}
-	}
-	if r.Limit < 0 {
-		errList = append(errList, errors.New("'limit' must be non-negative"))
-	}
-	if r.Limit > getUTXOsMaxLimit {
-		errList = append(errList, errors.Errorf("'limit' cannot exceed %d", getUTXOsMaxLimit))
+	if r.Id != "" && !isRuneIdOrRuneName(r.Id) {
+		errList = append(errList, errors.New("'id' is not valid rune id or rune name"))
 	}
 	return errs.WithPublicMessage(errors.Join(errList...), "validation error")
 }
@@ -60,22 +41,21 @@ type utxoExtend struct {
 	Runes []runeBalance `json:"runes"`
 }
 
-type utxoItem struct {
+type utxo struct {
 	TxHash      chainhash.Hash `json:"txHash"`
 	OutputIndex uint32         `json:"outputIndex"`
-	Sats        int64          `json:"sats"`
 	Extend      utxoExtend     `json:"extend"`
 }
 
-type getUTXOsResult struct {
-	List        []utxoItem `json:"list"`
-	BlockHeight uint64     `json:"blockHeight"`
+type getUTXOsByAddressResult struct {
+	List        []utxo `json:"list"`
+	BlockHeight uint64 `json:"blockHeight"`
 }
 
-type getUTXOsResponse = HttpResponse[getUTXOsResult]
+type getUTXOsByAddressResponse = HttpResponse[getUTXOsByAddressResult]
 
-func (h *HttpHandler) GetUTXOs(ctx *fiber.Ctx) (err error) {
-	var req getUTXOsRequest
+func (h *HttpHandler) GetUTXOsByAddress(ctx *fiber.Ctx) (err error) {
+	var req getUTXOsByAddressRequest
 	if err := ctx.ParamsParser(&req); err != nil {
 		return errors.WithStack(err)
 	}
@@ -85,9 +65,6 @@ func (h *HttpHandler) GetUTXOs(ctx *fiber.Ctx) (err error) {
 	if err := req.Validate(); err != nil {
 		return errors.WithStack(err)
 	}
-	if err := req.ParseDefault(); err != nil {
-		return errors.WithStack(err)
-	}
 
 	pkScript, ok := resolvePkScript(h.network, req.Wallet)
 	if !ok {
@@ -98,52 +75,32 @@ func (h *HttpHandler) GetUTXOs(ctx *fiber.Ctx) (err error) {
 	if blockHeight == 0 {
 		blockHeader, err := h.usecase.GetLatestBlock(ctx.UserContext())
 		if err != nil {
-			if errors.Is(err, errs.NotFound) {
-				return errs.NewPublicError("latest block not found")
-			}
 			return errors.Wrap(err, "error during GetLatestBlock")
 		}
 		blockHeight = uint64(blockHeader.Height)
 	}
 
-	var utxos []*entity.RunesUTXOWithSats
-	if runeId, ok := h.resolveRuneId(ctx.UserContext(), req.Id); ok {
-		utxos, err = h.usecase.GetRunesUTXOsByRuneIdAndPkScript(ctx.UserContext(), runeId, pkScript, blockHeight, req.Limit, req.Offset)
-		if err != nil {
-			if errors.Is(err, errs.NotFound) {
-				return errs.NewPublicError("utxos not found")
-			}
-			return errors.Wrap(err, "error during GetBalancesByPkScript")
-		}
-	} else {
-		utxos, err = h.usecase.GetRunesUTXOsByPkScript(ctx.UserContext(), pkScript, blockHeight, req.Limit, req.Offset)
-		if err != nil {
-			if errors.Is(err, errs.NotFound) {
-				return errs.NewPublicError("utxos not found")
-			}
-			return errors.Wrap(err, "error during GetBalancesByPkScript")
-		}
+	outPointBalances, err := h.usecase.GetUnspentOutPointBalancesByPkScript(ctx.UserContext(), pkScript, blockHeight)
+	if err != nil {
+		return errors.Wrap(err, "error during GetBalancesByPkScript")
 	}
 
-	runeIds := make(map[runes.RuneId]struct{}, 0)
-	for _, utxo := range utxos {
-		for _, balance := range utxo.RuneBalances {
-			runeIds[balance.RuneId] = struct{}{}
-		}
-	}
-	runeIdsList := lo.Keys(runeIds)
-	runeEntries, err := h.usecase.GetRuneEntryByRuneIdBatch(ctx.UserContext(), runeIdsList)
+	outPointBalanceRuneIds := lo.Map(outPointBalances, func(outPointBalance *entity.OutPointBalance, _ int) runes.RuneId {
+		return outPointBalance.RuneId
+	})
+	runeEntries, err := h.usecase.GetRuneEntryByRuneIdBatch(ctx.UserContext(), outPointBalanceRuneIds)
 	if err != nil {
-		if errors.Is(err, errs.NotFound) {
-			return errs.NewPublicError("rune entries not found")
-		}
 		return errors.Wrap(err, "error during GetRuneEntryByRuneIdBatch")
 	}
 
-	utxoRespList := make([]utxoItem, 0, len(utxos))
-	for _, utxo := range utxos {
-		runeBalances := make([]runeBalance, 0, len(utxo.RuneBalances))
-		for _, balance := range utxo.RuneBalances {
+	groupedBalances := lo.GroupBy(outPointBalances, func(outPointBalance *entity.OutPointBalance) wire.OutPoint {
+		return outPointBalance.OutPoint
+	})
+
+	utxoList := make([]utxo, 0, len(groupedBalances))
+	for outPoint, balances := range groupedBalances {
+		runeBalances := make([]runeBalance, 0, len(balances))
+		for _, balance := range balances {
 			runeEntry := runeEntries[balance.RuneId]
 			runeBalances = append(runeBalances, runeBalance{
 				RuneId:       balance.RuneId,
@@ -154,20 +111,34 @@ func (h *HttpHandler) GetUTXOs(ctx *fiber.Ctx) (err error) {
 			})
 		}
 
-		utxoRespList = append(utxoRespList, utxoItem{
-			TxHash:      utxo.OutPoint.Hash,
-			OutputIndex: utxo.OutPoint.Index,
-			Sats:        utxo.Sats,
+		utxoList = append(utxoList, utxo{
+			TxHash:      outPoint.Hash,
+			OutputIndex: outPoint.Index,
 			Extend: utxoExtend{
 				Runes: runeBalances,
 			},
 		})
 	}
 
-	resp := getUTXOsResponse{
-		Result: &getUTXOsResult{
+	// filter by req.Id if exists
+	{
+		runeId, ok := h.resolveRuneId(ctx.UserContext(), req.Id)
+		if ok {
+			utxoList = lo.Filter(utxoList, func(u utxo, _ int) bool {
+				for _, runeBalance := range u.Extend.Runes {
+					if runeBalance.RuneId == runeId {
+						return true
+					}
+				}
+				return false
+			})
+		}
+	}
+
+	resp := getUTXOsByAddressResponse{
+		Result: &getUTXOsByAddressResult{
 			BlockHeight: blockHeight,
-			List:        utxoRespList,
+			List:        utxoList,
 		},
 	}
 

modules/runes/api/httphandler/get_utxos_output_by_location.go

@@ -1,92 +0,0 @@
-package httphandler
-
-import (
-	"github.com/btcsuite/btcd/chaincfg/chainhash"
-	"github.com/cockroachdb/errors"
-	"github.com/gaze-network/indexer-network/common/errs"
-	"github.com/gaze-network/indexer-network/modules/runes/runes"
-	"github.com/gaze-network/indexer-network/modules/runes/usecase"
-	"github.com/gofiber/fiber/v2"
-	"github.com/samber/lo"
-)
-
-type getUTXOsOutputByLocationRequest struct {
-	TxHash      string `params:"txHash"`
-	OutputIndex int32  `query:"outputIndex"`
-}
-
-func (r getUTXOsOutputByLocationRequest) Validate() error {
-	var errList []error
-	if r.TxHash == "" {
-		errList = append(errList, errors.New("'txHash' is required"))
-	}
-	if r.OutputIndex < 0 {
-		errList = append(errList, errors.New("'outputIndex' must be non-negative"))
-	}
-	return errs.WithPublicMessage(errors.Join(errList...), "validation error")
-}
-
-type getUTXOsOutputByTxIdResponse = HttpResponse[utxoItem]
-
-func (h *HttpHandler) GetUTXOsOutputByLocation(ctx *fiber.Ctx) (err error) {
-	var req getUTXOsOutputByLocationRequest
-	if err := ctx.ParamsParser(&req); err != nil {
-		return errors.WithStack(err)
-	}
-	if err := ctx.QueryParser(&req); err != nil {
-		return errors.WithStack(err)
-	}
-	if err := req.Validate(); err != nil {
-		return errors.WithStack(err)
-	}
-
-	txHash, err := chainhash.NewHashFromStr(req.TxHash)
-	if err != nil {
-		return errs.WithPublicMessage(err, "unable to resolve txHash")
-	}
-
-	utxo, err := h.usecase.GetUTXOsOutputByLocation(ctx.UserContext(), *txHash, uint32(req.OutputIndex))
-	if err != nil {
-		if errors.Is(err, usecase.ErrUTXONotFound) {
-			return errs.NewPublicError("utxo not found")
-		}
-		return errors.WithStack(err)
-	}
-
-	runeIds := make(map[runes.RuneId]struct{}, 0)
-	for _, balance := range utxo.RuneBalances {
-		runeIds[balance.RuneId] = struct{}{}
-	}
-	runeIdsList := lo.Keys(runeIds)
-	runeEntries, err := h.usecase.GetRuneEntryByRuneIdBatch(ctx.UserContext(), runeIdsList)
-	if err != nil {
-		if errors.Is(err, errs.NotFound) {
-			return errs.NewPublicError("rune entries not found")
-		}
-		return errors.Wrap(err, "error during GetRuneEntryByRuneIdBatch")
-	}
-
-	runeBalances := make([]runeBalance, 0, len(utxo.RuneBalances))
-	for _, balance := range utxo.RuneBalances {
-		runeEntry := runeEntries[balance.RuneId]
-		runeBalances = append(runeBalances, runeBalance{
-			RuneId:       balance.RuneId,
-			Rune:         runeEntry.SpacedRune,
-			Symbol:       string(runeEntry.Symbol),
-			Amount:       balance.Amount,
-			Divisibility: runeEntry.Divisibility,
-		})
-	}
-
-	resp := getUTXOsOutputByTxIdResponse{
-		Result: &utxoItem{
-			TxHash:      utxo.OutPoint.Hash,
-			OutputIndex: utxo.OutPoint.Index,
-			Sats:        utxo.Sats,
-			Extend: utxoExtend{
-				Runes: runeBalances,
-			},
-		},
-	}
-	return errors.WithStack(ctx.JSON(resp))
-}

modules/runes/api/httphandler/get_utxos_output_by_location_batch.go

@@ -1,136 +0,0 @@
-package httphandler
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/btcsuite/btcd/chaincfg/chainhash"
-	"github.com/cockroachdb/errors"
-	"github.com/gaze-network/indexer-network/common/errs"
-	"github.com/gaze-network/indexer-network/modules/runes/runes"
-	"github.com/gaze-network/indexer-network/modules/runes/usecase"
-	"github.com/gofiber/fiber/v2"
-	"github.com/samber/lo"
-	"golang.org/x/sync/errgroup"
-)
-
-type getUTXOsOutputByLocationQuery struct {
-	TxHash      string `json:"txHash"`
-	OutputIndex int32  `json:"outputIndex"`
-}
-
-type getUTXOsOutputByLocationBatchRequest struct {
-	Queries []getUTXOsOutputByLocationQuery `json:"queries"`
-}
-
-const getUTXOsOutputByLocationBatchMaxQueries = 100
-
-func (r getUTXOsOutputByLocationBatchRequest) Validate() error {
-	var errList []error
-	if len(r.Queries) == 0 {
-		errList = append(errList, errors.New("at least one query is required"))
-	}
-	if len(r.Queries) > getUTXOsOutputByLocationBatchMaxQueries {
-		errList = append(errList, errors.Errorf("cannot exceed %d queries", getUTXOsOutputByLocationBatchMaxQueries))
-	}
-	for i, query := range r.Queries {
-		if query.TxHash == "" {
-			errList = append(errList, errors.Errorf("queries[%d]: 'txHash' is required", i))
-		}
-		if query.OutputIndex < 0 {
-			errList = append(errList, errors.Errorf("queries[%d]: 'outputIndex' must be non-negative", i))
-		}
-	}
-	return errs.WithPublicMessage(errors.Join(errList...), "validation error")
-}
-
-type getUTXOsOutputByLocationBatchResult struct {
-	List []*utxoItem `json:"list"`
-}
-
-type getUTXOsOutputByLocationBatchResponse = HttpResponse[getUTXOsOutputByLocationBatchResult]
-
-func (h *HttpHandler) GetUTXOsOutputByLocationBatch(ctx *fiber.Ctx) (err error) {
-	var req getUTXOsOutputByLocationBatchRequest
-	if err := ctx.BodyParser(&req); err != nil {
-		return errors.WithStack(err)
-	}
-	if err := req.Validate(); err != nil {
-		return errors.WithStack(err)
-	}
-
-	processQuery := func(ctx context.Context, query getUTXOsOutputByLocationQuery, queryIndex int) (*utxoItem, error) {
-		txHash, err := chainhash.NewHashFromStr(query.TxHash)
-		if err != nil {
-			return nil, errs.WithPublicMessage(err, fmt.Sprintf("unable to parse txHash from \"queries[%d].txHash\"", queryIndex))
-		}
-
-		utxo, err := h.usecase.GetUTXOsOutputByLocation(ctx, *txHash, uint32(query.OutputIndex))
-		if err != nil {
-			if errors.Is(err, usecase.ErrUTXONotFound) {
-				return nil, errs.NewPublicError(fmt.Sprintf("utxo not found for queries[%d]", queryIndex))
-			}
-			return nil, errors.WithStack(err)
-		}
-
-		runeIds := make(map[runes.RuneId]struct{}, 0)
-		for _, balance := range utxo.RuneBalances {
-			runeIds[balance.RuneId] = struct{}{}
-		}
-		runeIdsList := lo.Keys(runeIds)
-		runeEntries, err := h.usecase.GetRuneEntryByRuneIdBatch(ctx, runeIdsList)
-		if err != nil {
-			if errors.Is(err, errs.NotFound) {
-				return nil, errs.NewPublicError(fmt.Sprintf("rune entries not found for queries[%d]", queryIndex))
-			}
-			return nil, errors.Wrap(err, "error during GetRuneEntryByRuneIdBatch")
-		}
-
-		runeBalances := make([]runeBalance, 0, len(utxo.RuneBalances))
-		for _, balance := range utxo.RuneBalances {
-			runeEntry := runeEntries[balance.RuneId]
-			runeBalances = append(runeBalances, runeBalance{
-				RuneId:       balance.RuneId,
-				Rune:         runeEntry.SpacedRune,
-				Symbol:       string(runeEntry.Symbol),
-				Amount:       balance.Amount,
-				Divisibility: runeEntry.Divisibility,
-			})
-		}
-
-		return &utxoItem{
-			TxHash:      utxo.OutPoint.Hash,
-			OutputIndex: utxo.OutPoint.Index,
-			Sats:        utxo.Sats,
-			Extend: utxoExtend{
-				Runes: runeBalances,
-			},
-		}, nil
-	}
-
-	results := make([]*utxoItem, len(req.Queries))
-	eg, ectx := errgroup.WithContext(ctx.UserContext())
-	for i, query := range req.Queries {
-		i := i
-		query := query
-		eg.Go(func() error {
-			result, err := processQuery(ectx, query, i)
-			if err != nil {
-				return errors.Wrapf(err, "error during processQuery for query %d", i)
-			}
-			results[i] = result
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return errors.WithStack(err)
-	}
-
-	resp := getUTXOsOutputByLocationBatchResponse{
-		Result: &getUTXOsOutputByLocationBatchResult{
-			List: results,
-		},
-	}
-
-	return errors.WithStack(ctx.JSON(resp))
-}

modules/runes/api/httphandler/httphandler.go

@@ -7,9 +7,7 @@ import (
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/btcsuite/btcd/txscript"
-	"github.com/cockroachdb/errors"
 	"github.com/gaze-network/indexer-network/common"
-	"github.com/gaze-network/indexer-network/common/errs"
 	"github.com/gaze-network/indexer-network/modules/runes/runes"
 	"github.com/gaze-network/indexer-network/modules/runes/usecase"
 	"github.com/gaze-network/indexer-network/pkg/logger"
@@ -33,53 +31,6 @@ type HttpResponse[T any] struct {
 	Result *T      `json:"result,omitempty"`
 }
 
-type paginationRequest struct {
-	Offset int32 `query:"offset"`
-	Limit  int32 `query:"limit"`
-
-	// OrderBy string `query:"orderBy"` // ASC or DESC
-	// SortBy  string `query:"sortBy"`  // column name
-}
-
-func (req paginationRequest) Validate() error {
-	var errList []error
-
-	// this just safeguard for limit,
-	// each path should have own validation.
-	if req.Limit > 10000 {
-		errList = append(errList, errors.Errorf("too large limit"))
-	}
-	if req.Limit < 0 {
-		errList = append(errList, errors.Errorf("limit must be greater than or equal to 0"))
-	}
-	if req.Offset < 0 {
-		errList = append(errList, errors.Errorf("offset must be greater than or equal to 0"))
-	}
-
-	// TODO:
-	// if req.OrderBy != "" && req.OrderBy != "ASC" && req.OrderBy != "DESC" {
-	// 	errList = append(errList, errors.Errorf("invalid orderBy value, must be `ASC` or `DESC`"))
-	// }
-
-	return errs.WithPublicMessage(errors.Join(errList...), "pagination validation error")
-}
-
-func (req *paginationRequest) ParseDefault() error {
-	if req == nil {
-		return nil
-	}
-
-	if req.Limit == 0 {
-		req.Limit = 100
-	}
-
-	// TODO:
-	// if req.OrderBy == "" {
-	// 	req.OrderBy = "ASC"
-	// }
-	return nil
-}
-
 func resolvePkScript(network common.Network, wallet string) ([]byte, bool) {
 	if wallet == "" {
 		return nil, false
@@ -90,10 +41,6 @@ func resolvePkScript(network common.Network, wallet string) ([]byte, bool) {
 			return &chaincfg.MainNetParams
 		case common.NetworkTestnet:
 			return &chaincfg.TestNet3Params
-		case common.NetworkFractalMainnet:
-			return &chaincfg.MainNetParams
-		case common.NetworkFractalTestnet:
-			return &chaincfg.MainNetParams
 		}
 		panic("invalid network")
 	}()

modules/runes/api/httphandler/routes.go

@@ -7,17 +7,12 @@ import (
 func (h *HttpHandler) Mount(router fiber.Router) error {
 	r := router.Group("/v2/runes")
 
-	r.Post("/balances/wallet/batch", h.GetBalancesBatch)
-	r.Get("/balances/wallet/:wallet", h.GetBalances)
+	r.Post("/balances/wallet/batch", h.GetBalancesByAddressBatch)
+	r.Get("/balances/wallet/:wallet", h.GetBalancesByAddress)
 	r.Get("/transactions", h.GetTransactions)
-	r.Get("/transactions/hash/:hash", h.GetTransactionByHash)
 	r.Get("/holders/:id", h.GetHolders)
-	r.Post("/info/batch", h.GetTokenInfoBatch)
 	r.Get("/info/:id", h.GetTokenInfo)
-	r.Get("/utxos/wallet/:wallet", h.GetUTXOs)
-	r.Post("/utxos/output/batch", h.GetUTXOsOutputByLocationBatch)
-	r.Get("/utxos/output/:txHash", h.GetUTXOsOutputByLocation)
+	r.Get("/utxos/wallet/:wallet", h.GetUTXOsByAddress)
 	r.Get("/block", h.GetCurrentBlock)
-	r.Get("/tokens", h.GetTokens)
 	return nil
 }

modules/runes/constants.go

@@ -0,0 +1,27 @@
+package runes
+
+import (
+	"github.com/Cleverse/go-utilities/utils"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/gaze-network/indexer-network/common"
+	"github.com/gaze-network/indexer-network/core/types"
+)
+
+const (
+	Version          = "v0.0.1"
+	DBVersion        = 1
+	EventHashVersion = 1
+)
+
+var startingBlockHeader = map[common.Network]types.BlockHeader{
+	common.NetworkMainnet: {
+		Height:    839999,
+		Hash:      *utils.Must(chainhash.NewHashFromStr("0000000000000000000172014ba58d66455762add0512355ad651207918494ab")),
+		PrevBlock: *utils.Must(chainhash.NewHashFromStr("00000000000000000001dcce6ce7c8a45872cafd1fb04732b447a14a91832591")),
+	},
+	common.NetworkTestnet: {
+		Height:    2583200,
+		Hash:      *utils.Must(chainhash.NewHashFromStr("000000000006c5f0dfcd9e0e81f27f97a87aef82087ffe69cd3c390325bb6541")),
+		PrevBlock: *utils.Must(chainhash.NewHashFromStr("00000000000668f3bafac992f53424774515440cb47e1cb9e73af3f496139e28")),
+	},
+}

modules/runes/constants/constants.go

@@ -1,122 +0,0 @@
-package constants
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/btcsuite/btcd/chaincfg/chainhash"
-	"github.com/gaze-network/indexer-network/common"
-	"github.com/gaze-network/indexer-network/core/types"
-	"github.com/gaze-network/indexer-network/modules/runes/runes"
-	"github.com/gaze-network/indexer-network/pkg/logger"
-	"github.com/gaze-network/uint128"
-	"github.com/samber/lo"
-)
-
-const (
-	Version          = "v0.0.1"
-	DBVersion        = 1
-	EventHashVersion = 1
-)
-
-// starting block heights and hashes should be 1 block before activation block, as indexer will start from the block after this value
-var StartingBlockHeader = map[common.Network]types.BlockHeader{
-	common.NetworkMainnet: {
-		Height: 839999,
-	},
-	common.NetworkTestnet: {
-		Height: 2519999,
-	},
-	common.NetworkFractalMainnet: {
-		Height: 83999,
-	},
-	common.NetworkFractalTestnet: {
-		Height: 83999,
-	},
-}
-
-type GenesisRuneConfig struct {
-	RuneId        runes.RuneId
-	Name          string
-	Number        uint64
-	Divisibility  uint8
-	Premine       uint128.Uint128
-	SpacedRune    runes.SpacedRune
-	Symbol        rune
-	Terms         *runes.Terms
-	Turbo         bool
-	EtchingTxHash chainhash.Hash
-	EtchedAt      time.Time
-}
-
-var GenesisRuneConfigMap = map[common.Network]GenesisRuneConfig{
-	common.NetworkMainnet: {
-		RuneId:       runes.RuneId{BlockHeight: 1, TxIndex: 0},
-		Number:       0,
-		Divisibility: 0,
-		Premine:      uint128.Zero,
-		SpacedRune:   runes.NewSpacedRune(runes.NewRune(2055900680524219742), 0b10000000),
-		Symbol:       '\u29c9',
-		Terms: &runes.Terms{
-			Amount:      lo.ToPtr(uint128.From64(1)),
-			Cap:         &uint128.Max,
-			HeightStart: lo.ToPtr(uint64(840000)),
-			HeightEnd:   lo.ToPtr(uint64(1050000)),
-			OffsetStart: nil,
-			OffsetEnd:   nil,
-		},
-		Turbo:         true,
-		EtchingTxHash: chainhash.Hash{},
-		EtchedAt:      time.Unix(0, 0),
-	},
-	common.NetworkFractalMainnet: {
-		RuneId:       runes.RuneId{BlockHeight: 1, TxIndex: 0},
-		Number:       0,
-		Divisibility: 0,
-		Premine:      uint128.Zero,
-		SpacedRune:   runes.NewSpacedRune(runes.NewRune(2055900680524219742), 0b10000000),
-		Symbol:       '\u29c9',
-		Terms: &runes.Terms{
-			Amount:      lo.ToPtr(uint128.From64(1)),
-			Cap:         &uint128.Max,
-			HeightStart: lo.ToPtr(uint64(84000)),
-			HeightEnd:   lo.ToPtr(uint64(2184000)),
-			OffsetStart: nil,
-			OffsetEnd:   nil,
-		},
-		Turbo:         true,
-		EtchingTxHash: chainhash.Hash{},
-		EtchedAt:      time.Unix(0, 0),
-	},
-	common.NetworkFractalTestnet: {
-		RuneId:       runes.RuneId{BlockHeight: 1, TxIndex: 0},
-		Number:       0,
-		Divisibility: 0,
-		Premine:      uint128.Zero,
-		SpacedRune:   runes.NewSpacedRune(runes.NewRune(2055900680524219742), 0b10000000),
-		Symbol:       '\u29c9',
-		Terms: &runes.Terms{
-			Amount:      lo.ToPtr(uint128.From64(1)),
-			Cap:         &uint128.Max,
-			HeightStart: lo.ToPtr(uint64(84000)),
-			HeightEnd:   lo.ToPtr(uint64(2184000)),
-			OffsetStart: nil,
-			OffsetEnd:   nil,
-		},
-		Turbo:         true,
-		EtchingTxHash: chainhash.Hash{},
-		EtchedAt:      time.Unix(0, 0),
-	},
-}
-
-func NetworkHasGenesisRune(network common.Network) bool {
-	switch network {
-	case common.NetworkMainnet, common.NetworkFractalMainnet, common.NetworkFractalTestnet:
-		return true
-	case common.NetworkTestnet:
-		return false
-	default:
-		logger.Panic(fmt.Sprintf("unsupported network: %s", network))
-		return false
-	}
-}

modules/runes/database/postgresql/migrations/000001_initialize_tables.up.sql

@@ -1,6 +1,5 @@
 BEGIN;
 
-CREATE EXTENSION IF NOT EXISTS pg_trgm;
 -- Indexer Client Information
 
 CREATE TABLE IF NOT EXISTS "runes_indexer_stats" (
@@ -49,7 +48,6 @@ CREATE TABLE IF NOT EXISTS "runes_entries" (
 	"etched_at" TIMESTAMP NOT NULL
 );
 CREATE UNIQUE INDEX IF NOT EXISTS runes_entries_rune_idx ON "runes_entries" USING BTREE ("rune");
-CREATE INDEX IF NOT EXISTS runes_entries_rune_gin_idx ON "runes_entries" USING GIN ("rune" gin_trgm_ops); -- to speed up queries with LIKE operator
 CREATE UNIQUE INDEX IF NOT EXISTS runes_entries_number_idx ON "runes_entries" USING BTREE ("number");
 
 CREATE TABLE IF NOT EXISTS "runes_entry_states" (
@@ -120,7 +118,5 @@ CREATE TABLE IF NOT EXISTS "runes_balances" (
 	"amount" DECIMAL NOT NULL,
 	PRIMARY KEY ("pkscript", "rune_id", "block_height")
 );
-CREATE INDEX IF NOT EXISTS runes_balances_rune_id_block_height_idx ON "runes_balances" USING BTREE ("rune_id", "block_height");
-CREATE INDEX IF NOT EXISTS runes_balances_pkscript_block_height_idx ON "runes_balances" USING BTREE ("pkscript", "block_height");
 
 COMMIT;

modules/runes/database/postgresql/queries/batch.sql

@@ -1,104 +0,0 @@
--- name: BatchCreateRunesBalances :exec
-INSERT INTO runes_balances ("pkscript", "block_height", "rune_id", "amount")
-VALUES(
-  unnest(@pkscript_arr::TEXT[]),
-  unnest(@block_height_arr::INT[]),
-  unnest(@rune_id_arr::TEXT[]),
-  unnest(@amount_arr::DECIMAL[])
-);
-
--- name: BatchCreateRuneEntries :exec
-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(
-  unnest(@rune_id_arr::TEXT[]),
-  unnest(@rune_arr::TEXT[]),
-  unnest(@number_arr::BIGINT[]),
-  unnest(@spacers_arr::INT[]),
-  unnest(@premine_arr::DECIMAL[]),
-  unnest(@symbol_arr::INT[]),
-  unnest(@divisibility_arr::SMALLINT[]),
-  unnest(@terms_arr::BOOLEAN[]),
-  unnest(@terms_amount_arr::DECIMAL[]),
-  unnest(@terms_cap_arr::DECIMAL[]),
-  unnest(@terms_height_start_arr::INT[]), -- nullable (need patch)
-  unnest(@terms_height_end_arr::INT[]), -- nullable (need patch)
-  unnest(@terms_offset_start_arr::INT[]), -- nullable (need patch)
-  unnest(@terms_offset_end_arr::INT[]), -- nullable (need patch)
-  unnest(@turbo_arr::BOOLEAN[]),
-  unnest(@etching_block_arr::INT[]),
-  unnest(@etching_tx_hash_arr::TEXT[]),
-  unnest(@etched_at_arr::TIMESTAMP[])
-);
-
--- name: BatchCreateRuneEntryStates :exec
-INSERT INTO runes_entry_states ("rune_id", "block_height", "mints", "burned_amount", "completed_at", "completed_at_height")
-VALUES(
-  unnest(@rune_id_arr::TEXT[]),
-  unnest(@block_height_arr::INT[]),
-  unnest(@mints_arr::DECIMAL[]),
-  unnest(@burned_amount_arr::DECIMAL[]),
-  unnest(@completed_at_arr::TIMESTAMP[]),
-  unnest(@completed_at_height_arr::INT[]) -- nullable (need patch)
-);
-
--- name: BatchCreateRunesOutpointBalances :exec
-INSERT INTO runes_outpoint_balances ("rune_id", "pkscript", "tx_hash", "tx_idx", "amount", "block_height", "spent_height")
-VALUES(
-  unnest(@rune_id_arr::TEXT[]),
-  unnest(@pkscript_arr::TEXT[]),
-  unnest(@tx_hash_arr::TEXT[]),
-  unnest(@tx_idx_arr::INT[]),
-  unnest(@amount_arr::DECIMAL[]),
-  unnest(@block_height_arr::INT[]),
-  unnest(@spent_height_arr::INT[]) -- nullable (need patch)
-);
-
--- name: BatchSpendOutpointBalances :exec
-UPDATE runes_outpoint_balances
-	SET "spent_height" = @spent_height::INT
-	FROM (
-    SELECT 
-      unnest(@tx_hash_arr::TEXT[]) AS tx_hash, 
-      unnest(@tx_idx_arr::INT[]) AS tx_idx
-    ) AS input
-	WHERE "runes_outpoint_balances"."tx_hash" = "input"."tx_hash" AND "runes_outpoint_balances"."tx_idx" = "input"."tx_idx";
-
--- name: BatchCreateRunestones :exec
-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(
-  unnest(@tx_hash_arr::TEXT[]),
-  unnest(@block_height_arr::INT[]),
-  unnest(@etching_arr::BOOLEAN[]),
-  unnest(@etching_divisibility_arr::SMALLINT[]), -- nullable (need patch)
-  unnest(@etching_premine_arr::DECIMAL[]),
-  unnest(@etching_rune_arr::TEXT[]), -- nullable (need patch)
-  unnest(@etching_spacers_arr::INT[]), -- nullable (need patch)
-  unnest(@etching_symbol_arr::INT[]), -- nullable (need patch)
-  unnest(@etching_terms_arr::BOOLEAN[]), -- nullable (need patch)
-  unnest(@etching_terms_amount_arr::DECIMAL[]),
-  unnest(@etching_terms_cap_arr::DECIMAL[]),
-  unnest(@etching_terms_height_start_arr::INT[]), -- nullable (need patch)
-  unnest(@etching_terms_height_end_arr::INT[]), -- nullable (need patch)
-  unnest(@etching_terms_offset_start_arr::INT[]), -- nullable (need patch)
-  unnest(@etching_terms_offset_end_arr::INT[]), -- nullable (need patch)
-  unnest(@etching_turbo_arr::BOOLEAN[]), -- nullable (need patch)
-  unnest(@edicts_arr::JSONB[]),
-  unnest(@mint_arr::TEXT[]), -- nullable (need patch)
-  unnest(@pointer_arr::INT[]), -- nullable (need patch)
-  unnest(@cenotaph_arr::BOOLEAN[]),
-  unnest(@flaws_arr::INT[])
-);
-
--- name: BatchCreateRuneTransactions :exec
-INSERT INTO runes_transactions ("hash", "block_height", "index", "timestamp", "inputs", "outputs", "mints", "burns", "rune_etched")
-VALUES (
-  unnest(@hash_arr::TEXT[]),
-  unnest(@block_height_arr::INT[]),
-  unnest(@index_arr::INT[]),
-  unnest(@timestamp_arr::TIMESTAMP[]),
-  unnest(@inputs_arr::JSONB[]),
-  unnest(@outputs_arr::JSONB[]),
-  unnest(@mints_arr::JSONB[]),
-  unnest(@burns_arr::JSONB[]),
-  unnest(@rune_etched_arr::BOOLEAN[])
-);

modules/runes/database/postgresql/queries/data.sql

@@ -2,48 +2,22 @@
 WITH balances AS (
   SELECT DISTINCT ON (rune_id) * FROM runes_balances WHERE pkscript = $1 AND block_height <= $2 ORDER BY rune_id, block_height DESC
 )
-SELECT * FROM balances WHERE amount > 0 ORDER BY amount DESC, rune_id LIMIT $3 OFFSET $4;
+SELECT * FROM balances WHERE amount > 0;
 
 -- name: GetBalancesByRuneId :many
 WITH balances AS (
   SELECT DISTINCT ON (pkscript) * FROM runes_balances WHERE rune_id = $1 AND block_height <= $2 ORDER BY pkscript, block_height DESC
 )
-SELECT * FROM balances WHERE amount > 0 ORDER BY amount DESC, pkscript LIMIT $3 OFFSET $4;
+SELECT * FROM balances WHERE amount > 0;
 
 -- name: GetBalanceByPkScriptAndRuneId :one
 SELECT * FROM runes_balances WHERE pkscript = $1 AND rune_id = $2 AND block_height <= $3 ORDER BY block_height DESC LIMIT 1;
 
--- name: GetTotalHoldersByRuneIds :many
-WITH balances AS (
-  SELECT DISTINCT ON (rune_id, pkscript) * FROM runes_balances WHERE rune_id = ANY(@rune_ids::TEXT[]) AND block_height <= @block_height ORDER BY rune_id, pkscript, block_height DESC
-)
-SELECT rune_id, COUNT(DISTINCT pkscript) FROM balances WHERE amount > 0 GROUP BY rune_id;
-
 -- name: GetOutPointBalancesAtOutPoint :many
 SELECT * FROM runes_outpoint_balances WHERE tx_hash = $1 AND tx_idx = $2;
 
--- name: GetRunesUTXOsByPkScript :many
-SELECT tx_hash, tx_idx, max("pkscript") as pkscript, array_agg("rune_id") as rune_ids, array_agg("amount") as amounts 
-  FROM runes_outpoint_balances 
-  WHERE
-    pkscript = @pkScript AND
-    block_height <= @block_height AND
-    (spent_height IS NULL OR spent_height > @block_height)
-  GROUP BY tx_hash, tx_idx
-  ORDER BY tx_hash, tx_idx 
-  LIMIT $1 OFFSET $2;
-
--- name: GetRunesUTXOsByRuneIdAndPkScript :many
-SELECT tx_hash, tx_idx, max("pkscript") as pkscript, array_agg("rune_id") as rune_ids, array_agg("amount") as amounts 
-  FROM runes_outpoint_balances 
-  WHERE
-    pkscript = @pkScript AND 
-    block_height <= @block_height AND 
-    (spent_height IS NULL OR spent_height > @block_height)
-  GROUP BY tx_hash, tx_idx
-  HAVING array_agg("rune_id") @> @rune_ids::text[] 
-  ORDER BY tx_hash, tx_idx 
-  LIMIT $1 OFFSET $2;
+-- name: GetUnspentOutPointBalancesByPkScript :many
+SELECT * FROM runes_outpoint_balances WHERE pkscript = @pkScript AND block_height <= @block_height AND (spent_height IS NULL OR spent_height > @block_height);
 
 -- name: GetRuneEntriesByRuneIds :many
 WITH states AS (
@@ -63,49 +37,6 @@ SELECT * FROM runes_entries
   LEFT JOIN states ON runes_entries.rune_id = states.rune_id
   WHERE runes_entries.rune_id = ANY(@rune_ids::text[]) AND etching_block <= @height;
 
--- name: GetRuneEntries :many
-WITH states AS (
-  -- select latest state
-  SELECT DISTINCT ON (rune_id) * FROM runes_entry_states WHERE block_height <= @height ORDER BY rune_id, block_height DESC
-)
-SELECT * FROM runes_entries 
-  LEFT JOIN states ON runes_entries.rune_id = states.rune_id
-  WHERE (
-    @search = '' OR
-    runes_entries.rune ILIKE @search || '%'
-  )
-  ORDER BY runes_entries.number 
-  LIMIT @_limit OFFSET @_offset;
-
--- name: GetOngoingRuneEntries :many
-WITH states AS (
-  -- select latest state
-  SELECT DISTINCT ON (rune_id) * FROM runes_entry_states WHERE block_height <= @height::integer ORDER BY rune_id, block_height DESC
-)
-SELECT * FROM runes_entries 
-  LEFT JOIN states ON runes_entries.rune_id = states.rune_id
-  WHERE (
-    runes_entries.terms = TRUE AND
-    COALESCE(runes_entries.terms_amount, 0) != 0 AND
-    COALESCE(runes_entries.terms_cap, 0) != 0 AND
-    states.mints < runes_entries.terms_cap AND
-    (
-      runes_entries.terms_height_start IS NULL OR runes_entries.terms_height_start <= @height::integer
-    ) AND (
-      runes_entries.terms_height_end IS NULL OR @height::integer <= runes_entries.terms_height_end
-    ) AND (
-      runes_entries.terms_offset_start IS NULL OR runes_entries.terms_offset_start + runes_entries.etching_block <= @height::integer
-    ) AND (
-      runes_entries.terms_offset_end IS NULL OR @height::integer <= runes_entries.terms_offset_start + runes_entries.etching_block
-    )
-
-  ) AND (
-    @search::text = '' OR
-    runes_entries.rune ILIKE '%' || @search::text || '%'
-  )
-  ORDER BY states.mints DESC
-  LIMIT @_limit OFFSET @_offset;
-
 -- name: GetRuneIdFromRune :one
 SELECT rune_id FROM runes_entries WHERE rune = $1;
 
@@ -124,14 +55,8 @@ SELECT * FROM runes_transactions
     OR runes_transactions.burns ? @rune_id
     OR (runes_transactions.rune_etched = TRUE AND runes_transactions.block_height = @rune_id_block_height AND runes_transactions.index = @rune_id_tx_index)
   ) AND (
-    @from_block <= runes_transactions.block_height AND runes_transactions.block_height <= @to_block
-  )
-ORDER BY runes_transactions.block_height DESC, runes_transactions.index DESC LIMIT $1 OFFSET $2;
-
--- name: GetRuneTransaction :one
-SELECT * FROM runes_transactions
-  LEFT JOIN runes_runestones ON runes_transactions.hash = runes_runestones.tx_hash
-  WHERE hash = $1 LIMIT 1;
+    @block_height::INT = 0 OR runes_transactions.block_height = @block_height::INT -- if @block_height > 0, apply block_height filter
+  );
 
 -- name: CountRuneEntries :one
 SELECT COUNT(*) FROM runes_entries;
@@ -150,13 +75,13 @@ INSERT INTO runes_transactions (hash, block_height, index, timestamp, inputs, ou
 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: CreateOutPointBalance :exec
+-- 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: SpendOutPointBalance :exec
+-- name: SpendOutPointBalances :exec
 UPDATE runes_outpoint_balances SET spent_height = $1 WHERE tx_hash = $2 AND tx_idx = $3;
 
--- name: CreateRuneBalance :exec
+-- name: CreateRuneBalanceAtBlock :batchexec
 INSERT INTO runes_balances (pkscript, block_height, rune_id, amount) VALUES ($1, $2, $3, $4);
 
 -- name: GetLatestIndexedBlock :one

modules/runes/datagateway/runes.go

@@ -3,11 +3,11 @@ package datagateway
 import (
 	"context"
 
-	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/gaze-network/indexer-network/core/types"
 	"github.com/gaze-network/indexer-network/modules/runes/internal/entity"
 	"github.com/gaze-network/indexer-network/modules/runes/runes"
+	"github.com/gaze-network/uint128"
 )
 
 type RunesDataGateway interface {
@@ -27,12 +27,10 @@ type RunesReaderDataGateway interface {
 	GetLatestBlock(ctx context.Context) (types.BlockHeader, error)
 	GetIndexedBlockByHeight(ctx context.Context, height int64) (*entity.IndexedBlock, error)
 	// GetRuneTransactions returns the runes transactions, filterable by pkScript, runeId and height. If pkScript, runeId or height is zero value, that filter is ignored.
-	GetRuneTransactions(ctx context.Context, pkScript []byte, runeId runes.RuneId, fromBlock, toBlock uint64, limit int32, offset int32) ([]*entity.RuneTransaction, error)
-	GetRuneTransaction(ctx context.Context, txHash chainhash.Hash) (*entity.RuneTransaction, error)
+	GetRuneTransactions(ctx context.Context, pkScript []byte, runeId runes.RuneId, height uint64) ([]*entity.RuneTransaction, error)
 
 	GetRunesBalancesAtOutPoint(ctx context.Context, outPoint wire.OutPoint) (map[runes.RuneId]*entity.OutPointBalance, error)
-	GetRunesUTXOsByRuneIdAndPkScript(ctx context.Context, runeId runes.RuneId, pkScript []byte, blockHeight uint64, limit int32, offset int32) ([]*entity.RunesUTXO, error)
-	GetRunesUTXOsByPkScript(ctx context.Context, pkScript []byte, blockHeight uint64, limit int32, offset int32) ([]*entity.RunesUTXO, error)
+	GetUnspentOutPointBalancesByPkScript(ctx context.Context, pkScript []byte, blockHeight uint64) ([]*entity.OutPointBalance, error)
 	// GetRuneIdFromRune returns the RuneId for the given rune. Returns errs.NotFound if the rune entry is not found.
 	GetRuneIdFromRune(ctx context.Context, rune runes.Rune) (runes.RuneId, error)
 	// GetRuneEntryByRuneId returns the RuneEntry for the given runeId. Returns errs.NotFound if the rune entry is not found.
@@ -43,33 +41,25 @@ type RunesReaderDataGateway interface {
 	GetRuneEntryByRuneIdAndHeight(ctx context.Context, runeId runes.RuneId, blockHeight uint64) (*runes.RuneEntry, error)
 	// GetRuneEntryByRuneIdAndHeightBatch returns the RuneEntries for the given runeIds and block height.
 	GetRuneEntryByRuneIdAndHeightBatch(ctx context.Context, runeIds []runes.RuneId, blockHeight uint64) (map[runes.RuneId]*runes.RuneEntry, error)
-	// GetRuneEntries returns a list of rune entries, sorted by etching order. If search is not empty, it will filter the results by rune name (prefix).
-	GetRuneEntries(ctx context.Context, search string, blockHeight uint64, limit int32, offset int32) ([]*runes.RuneEntry, error)
-	// GetOngoingRuneEntries returns a list of ongoing rune entries (can still mint), sorted by mint progress percent. If search is not empty, it will filter the results by rune name (prefix).
-	GetOngoingRuneEntries(ctx context.Context, search string, blockHeight uint64, limit int32, offset int32) ([]*runes.RuneEntry, error)
 	// CountRuneEntries returns the number of existing rune entries.
 	CountRuneEntries(ctx context.Context) (uint64, error)
 
 	// GetBalancesByPkScript returns the balances for the given pkScript at the given blockHeight.
-	// Use limit = -1 as no limit.
-	GetBalancesByPkScript(ctx context.Context, pkScript []byte, blockHeight uint64, limit int32, offset int32) ([]*entity.Balance, error)
+	GetBalancesByPkScript(ctx context.Context, pkScript []byte, blockHeight uint64) (map[runes.RuneId]*entity.Balance, error)
 	// GetBalancesByRuneId returns the balances for the given runeId at the given blockHeight.
 	// Cannot use []byte as map key, so we're returning as slice.
-	// Use limit = -1 as no limit.
-	GetBalancesByRuneId(ctx context.Context, runeId runes.RuneId, blockHeight uint64, limit int32, offset int32) ([]*entity.Balance, error)
+	GetBalancesByRuneId(ctx context.Context, runeId runes.RuneId, blockHeight uint64) ([]*entity.Balance, error)
 	// GetBalancesByPkScriptAndRuneId returns the balance for the given pkScript and runeId at the given blockHeight.
 	GetBalanceByPkScriptAndRuneId(ctx context.Context, pkScript []byte, runeId runes.RuneId, blockHeight uint64) (*entity.Balance, error)
-	// GetTotalHoldersByRuneIds returns the total holders of each the given runeIds.
-	GetTotalHoldersByRuneIds(ctx context.Context, runeIds []runes.RuneId, blockHeight uint64) (map[runes.RuneId]int64, error)
 }
 
 type RunesWriterDataGateway interface {
-	CreateRuneEntries(ctx context.Context, entries []*runes.RuneEntry) error
-	CreateRuneEntryStates(ctx context.Context, entries []*runes.RuneEntry, blockHeight uint64) error
+	CreateRuneEntry(ctx context.Context, entry *runes.RuneEntry, blockHeight uint64) error
+	CreateRuneEntryState(ctx context.Context, entry *runes.RuneEntry, blockHeight uint64) error
 	CreateOutPointBalances(ctx context.Context, outPointBalances []*entity.OutPointBalance) error
-	SpendOutPointBalancesBatch(ctx context.Context, outPoints []wire.OutPoint, blockHeight uint64) error
-	CreateRuneBalances(ctx context.Context, params []*entity.Balance) error
-	CreateRuneTransactions(ctx context.Context, txs []*entity.RuneTransaction) error
+	SpendOutPointBalances(ctx context.Context, outPoint wire.OutPoint, blockHeight uint64) error
+	CreateRuneBalances(ctx context.Context, params []CreateRuneBalancesParams) error
+	CreateRuneTransaction(ctx context.Context, tx *entity.RuneTransaction) error
 	CreateIndexedBlock(ctx context.Context, block *entity.IndexedBlock) error
 
 	// TODO: collapse these into a single function (ResetStateToHeight)?
@@ -82,3 +72,10 @@ type RunesWriterDataGateway interface {
 	UnspendOutPointBalancesSinceHeight(ctx context.Context, height uint64) error
 	DeleteRuneBalancesSinceHeight(ctx context.Context, height uint64) error
 }
+
+type CreateRuneBalancesParams struct {
+	PkScript    []byte
+	RuneId      runes.RuneId
+	Balance     uint128.Uint128
+	BlockHeight uint64
+}

modules/runes/event_hash.go

@@ -11,7 +11,6 @@ import (
 	"github.com/btcsuite/btcd/wire"
 	"github.com/cockroachdb/errors"
 	"github.com/gaze-network/indexer-network/core/types"
-	"github.com/gaze-network/indexer-network/modules/runes/constants"
 	"github.com/gaze-network/indexer-network/modules/runes/internal/entity"
 	"github.com/gaze-network/indexer-network/modules/runes/runes"
 	"github.com/gaze-network/uint128"
@@ -29,7 +28,7 @@ func (p *Processor) calculateEventHash(header types.BlockHeader) (chainhash.Hash
 
 func (p *Processor) getHashPayload(header types.BlockHeader) ([]byte, error) {
 	var sb strings.Builder
-	sb.WriteString("payload:v" + strconv.Itoa(constants.EventHashVersion) + ":")
+	sb.WriteString("payload:v" + strconv.Itoa(EventHashVersion) + ":")
 	sb.WriteString("blockHash:")
 	sb.Write(header.Hash[:])
 

modules/runes/internal/entity/runes_utxo.go

@@ -1,23 +0,0 @@
-package entity
-
-import (
-	"github.com/btcsuite/btcd/wire"
-	"github.com/gaze-network/indexer-network/modules/runes/runes"
-	"github.com/gaze-network/uint128"
-)
-
-type RunesUTXOBalance struct {
-	RuneId runes.RuneId
-	Amount uint128.Uint128
-}
-
-type RunesUTXO struct {
-	PkScript     []byte
-	OutPoint     wire.OutPoint
-	RuneBalances []RunesUTXOBalance
-}
-
-type RunesUTXOWithSats struct {
-	RunesUTXO
-	Sats int64
-}

modules/runes/processor.go

@@ -4,13 +4,13 @@ import (
 	"context"
 	"time"
 
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/cockroachdb/errors"
 	"github.com/gaze-network/indexer-network/common"
 	"github.com/gaze-network/indexer-network/common/errs"
 	"github.com/gaze-network/indexer-network/core/indexer"
 	"github.com/gaze-network/indexer-network/core/types"
-	"github.com/gaze-network/indexer-network/modules/runes/constants"
 	"github.com/gaze-network/indexer-network/modules/runes/datagateway"
 	"github.com/gaze-network/indexer-network/modules/runes/internal/entity"
 	"github.com/gaze-network/indexer-network/modules/runes/runes"
@@ -19,6 +19,7 @@ import (
 	"github.com/gaze-network/indexer-network/pkg/logger/slogx"
 	"github.com/gaze-network/indexer-network/pkg/reportingclient"
 	"github.com/gaze-network/uint128"
+	"github.com/samber/lo"
 )
 
 // Make sure to implement the Bitcoin Processor interface
@@ -30,7 +31,6 @@ type Processor struct {
 	bitcoinClient   btcclient.Contract
 	network         common.Network
 	reportingClient *reportingclient.ReportingClient
-	cleanupFuncs    []func(context.Context) error
 
 	newRuneEntries      map[runes.RuneId]*runes.RuneEntry
 	newRuneEntryStates  map[runes.RuneId]*runes.RuneEntry
@@ -40,14 +40,13 @@ type Processor struct {
 	newRuneTxs          []*entity.RuneTransaction
 }
 
-func NewProcessor(runesDg datagateway.RunesDataGateway, indexerInfoDg datagateway.IndexerInfoDataGateway, bitcoinClient btcclient.Contract, network common.Network, reportingClient *reportingclient.ReportingClient, cleanupFuncs []func(context.Context) error) *Processor {
+func NewProcessor(runesDg datagateway.RunesDataGateway, indexerInfoDg datagateway.IndexerInfoDataGateway, bitcoinClient btcclient.Contract, network common.Network, reportingClient *reportingclient.ReportingClient) *Processor {
 	return &Processor{
 		runesDg:             runesDg,
 		indexerInfoDg:       indexerInfoDg,
 		bitcoinClient:       bitcoinClient,
 		network:             network,
 		reportingClient:     reportingClient,
-		cleanupFuncs:        cleanupFuncs,
 		newRuneEntries:      make(map[runes.RuneId]*runes.RuneEntry),
 		newRuneEntryStates:  make(map[runes.RuneId]*runes.RuneEntry),
 		newOutPointBalances: make(map[wire.OutPoint][]*entity.OutPointBalance),
@@ -67,8 +66,8 @@ func (p *Processor) VerifyStates(ctx context.Context) error {
 	if err := p.ensureValidState(ctx); err != nil {
 		return errors.Wrap(err, "error during ensureValidState")
 	}
-	if constants.NetworkHasGenesisRune(p.network) {
-		if err := p.ensureGenesisRune(ctx, p.network); err != nil {
+	if p.network == common.NetworkMainnet {
+		if err := p.ensureGenesisRune(ctx); err != nil {
 			return errors.Wrap(err, "error during ensureGenesisRune")
 		}
 	}
@@ -88,17 +87,17 @@ func (p *Processor) ensureValidState(ctx context.Context) error {
 	// if not found, set indexer state
 	if errors.Is(err, errs.NotFound) {
 		if err := p.indexerInfoDg.SetIndexerState(ctx, entity.IndexerState{
-			DBVersion:        constants.DBVersion,
-			EventHashVersion: constants.EventHashVersion,
+			DBVersion:        DBVersion,
+			EventHashVersion: EventHashVersion,
 		}); err != nil {
 			return errors.Wrap(err, "failed to set indexer state")
 		}
 	} else {
-		if indexerState.DBVersion != constants.DBVersion {
-			return errors.Wrapf(errs.ConflictSetting, "db version mismatch: current version is %d. Please upgrade to version %d", indexerState.DBVersion, constants.DBVersion)
+		if indexerState.DBVersion != DBVersion {
+			return errors.Wrapf(errs.ConflictSetting, "db version mismatch: current version is %d. Please upgrade to version %d", indexerState.DBVersion, DBVersion)
 		}
-		if indexerState.EventHashVersion != constants.EventHashVersion {
-			return errors.Wrapf(errs.ConflictSetting, "event version mismatch: current version is %d. Please reset rune's db first.", indexerState.EventHashVersion, constants.EventHashVersion)
+		if indexerState.EventHashVersion != EventHashVersion {
+			return errors.Wrapf(errs.ConflictSetting, "event version mismatch: current version is %d. Please reset rune's db first.", indexerState.EventHashVersion, EventHashVersion)
 		}
 	}
 
@@ -118,37 +117,39 @@ func (p *Processor) ensureValidState(ctx context.Context) error {
 	return nil
 }
 
-func (p *Processor) ensureGenesisRune(ctx context.Context, network common.Network) error {
-	genesisRuneConfig, ok := constants.GenesisRuneConfigMap[network]
-	if !ok {
-		logger.Panic("genesis rune config not found", slogx.Stringer("network", network))
-	}
-	_, err := p.runesDg.GetRuneEntryByRuneId(ctx, genesisRuneConfig.RuneId)
+var genesisRuneId = runes.RuneId{BlockHeight: 1, TxIndex: 0}
+
+func (p *Processor) ensureGenesisRune(ctx context.Context) error {
+	_, err := p.runesDg.GetRuneEntryByRuneId(ctx, genesisRuneId)
 	if err != nil && !errors.Is(err, errs.NotFound) {
 		return errors.Wrap(err, "failed to get genesis rune entry")
 	}
 	if errors.Is(err, errs.NotFound) {
 		runeEntry := &runes.RuneEntry{
-			RuneId:            genesisRuneConfig.RuneId,
-			Number:            genesisRuneConfig.Number,
-			Divisibility:      genesisRuneConfig.Divisibility,
-			Premine:           genesisRuneConfig.Premine,
-			SpacedRune:        genesisRuneConfig.SpacedRune,
-			Symbol:            genesisRuneConfig.Symbol,
-			Terms:             genesisRuneConfig.Terms,
-			Turbo:             genesisRuneConfig.Turbo,
+			RuneId:       genesisRuneId,
+			Number:       0,
+			Divisibility: 0,
+			Premine:      uint128.Zero,
+			SpacedRune:   runes.NewSpacedRune(runes.NewRune(2055900680524219742), 0b10000000),
+			Symbol:       '\u29c9',
+			Terms: &runes.Terms{
+				Amount:      lo.ToPtr(uint128.From64(1)),
+				Cap:         &uint128.Max,
+				HeightStart: lo.ToPtr(uint64(common.HalvingInterval * 4)),
+				HeightEnd:   lo.ToPtr(uint64(common.HalvingInterval * 5)),
+				OffsetStart: nil,
+				OffsetEnd:   nil,
+			},
+			Turbo:             true,
 			Mints:             uint128.Zero,
 			BurnedAmount:      uint128.Zero,
 			CompletedAt:       time.Time{},
 			CompletedAtHeight: nil,
-			EtchingBlock:      genesisRuneConfig.RuneId.BlockHeight,
-			EtchingTxHash:     genesisRuneConfig.EtchingTxHash,
-			EtchedAt:          genesisRuneConfig.EtchedAt,
+			EtchingBlock:      1,
+			EtchingTxHash:     chainhash.Hash{},
+			EtchedAt:          time.Time{},
 		}
-		if err := p.runesDg.CreateRuneEntries(ctx, []*runes.RuneEntry{runeEntry}); 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 {
+		if err := p.runesDg.CreateRuneEntry(ctx, runeEntry, genesisRuneId.BlockHeight); err != nil {
 			return errors.Wrap(err, "failed to create genesis rune entry")
 		}
 	}
@@ -163,7 +164,7 @@ func (p *Processor) CurrentBlock(ctx context.Context) (types.BlockHeader, error)
 	blockHeader, err := p.runesDg.GetLatestBlock(ctx)
 	if err != nil {
 		if errors.Is(err, errs.NotFound) {
-			return constants.StartingBlockHeader[p.network], nil
+			return startingBlockHeader[p.network], nil
 		}
 		return types.BlockHeader{}, errors.Wrap(err, "failed to get latest block")
 	}
@@ -227,13 +228,3 @@ func (p *Processor) RevertData(ctx context.Context, from int64) error {
 	}
 	return nil
 }
-
-func (p *Processor) Shutdown(ctx context.Context) error {
-	var errs []error
-	for _, cleanup := range p.cleanupFuncs {
-		if err := cleanup(ctx); err != nil {
-			errs = append(errs, err)
-		}
-	}
-	return errors.WithStack(errors.Join(errs...))
-}

modules/runes/processor_process.go

@@ -13,7 +13,7 @@ import (
 	"github.com/cockroachdb/errors"
 	"github.com/gaze-network/indexer-network/common/errs"
 	"github.com/gaze-network/indexer-network/core/types"
-	"github.com/gaze-network/indexer-network/modules/runes/constants"
+	"github.com/gaze-network/indexer-network/modules/runes/datagateway"
 	"github.com/gaze-network/indexer-network/modules/runes/internal/entity"
 	"github.com/gaze-network/indexer-network/modules/runes/runes"
 	"github.com/gaze-network/indexer-network/pkg/logger"
@@ -26,26 +26,19 @@ 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.InfoContext(ctx, "Processing new block",
-			slogx.String("event", "runes_processor_processing_block"),
-			slog.Int("txs", len(block.Transactions)),
-		)
+		logger.DebugContext(ctx, "Processing new 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
 }
@@ -153,7 +146,7 @@ func (p *Processor) processTx(ctx context.Context, tx *types.Transaction, blockH
 					// find all non-OP_RETURN outputs
 					var destinations []int
 					for i, txOut := range tx.TxOut {
-						if !txOut.IsOpReturn() {
+						if txOut.IsOpReturn() {
 							destinations = append(destinations, i)
 						}
 					}
@@ -473,7 +466,7 @@ func (p *Processor) txCommitsToRune(ctx context.Context, tx *types.Transaction,
 			// It is impossible to verify that input utxo is a P2TR output with just the input.
 			// Need to verify with utxo's pk script.
 
-			prevTx, blockHeight, err := p.bitcoinClient.GetRawTransactionAndHeightByTxHash(ctx, txIn.PreviousOutTxHash)
+			prevTx, err := p.bitcoinClient.GetTransactionByHash(ctx, txIn.PreviousOutTxHash)
 			if err != nil && errors.Is(err, errs.NotFound) {
 				continue
 			}
@@ -486,7 +479,7 @@ func (p *Processor) txCommitsToRune(ctx context.Context, tx *types.Transaction,
 				break
 			}
 			// input must be mature enough
-			confirmations := tx.BlockHeight - blockHeight + 1
+			confirmations := tx.BlockHeight - prevTx.BlockHeight + 1
 			if confirmations < runes.RUNE_COMMIT_BLOCKS {
 				continue
 			}
@@ -675,7 +668,6 @@ 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")
@@ -695,10 +687,10 @@ func (p *Processor) flushBlock(ctx context.Context, blockHeader types.BlockHeade
 		return errors.Wrap(err, "failed to calculate event hash")
 	}
 	prevIndexedBlock, err := runesDgTx.GetIndexedBlockByHeight(ctx, blockHeader.Height-1)
-	if err != nil && errors.Is(err, errs.NotFound) && blockHeader.Height-1 == constants.StartingBlockHeader[p.network].Height {
+	if err != nil && errors.Is(err, errs.NotFound) && blockHeader.Height-1 == startingBlockHeader[p.network].Height {
 		prevIndexedBlock = &entity.IndexedBlock{
-			Height:              constants.StartingBlockHeader[p.network].Height,
-			Hash:                chainhash.Hash{},
+			Height:              startingBlockHeader[p.network].Height,
+			Hash:                startingBlockHeader[p.network].Hash,
 			EventHash:           chainhash.Hash{},
 			CumulativeEventHash: chainhash.Hash{},
 		}
@@ -722,90 +714,86 @@ func (p *Processor) flushBlock(ctx context.Context, blockHeader types.BlockHeade
 		return errors.Wrap(err, "failed to create indexed block")
 	}
 	// flush new rune entries
-	newRuneEntries := lo.Values(p.newRuneEntries)
-	if err := runesDgTx.CreateRuneEntries(ctx, newRuneEntries); err != nil {
-		return errors.Wrap(err, "failed to create rune entry")
+	{
+		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)
 	}
-	p.newRuneEntries = make(map[runes.RuneId]*runes.RuneEntry)
-
 	// flush new rune entry states
-	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")
+	{
+		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)
 	}
-	p.newRuneEntryStates = make(map[runes.RuneId]*runes.RuneEntry)
-
 	// flush new outpoint balances
-	newOutpointBalances := make([]*entity.OutPointBalance, 0)
-	for _, balances := range p.newOutPointBalances {
-		newOutpointBalances = append(newOutpointBalances, 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)
 	}
-	if err := runesDgTx.CreateOutPointBalances(ctx, newOutpointBalances); err != nil {
-		return errors.Wrap(err, "failed to create outpoint balances")
-	}
-	p.newOutPointBalances = make(map[wire.OutPoint][]*entity.OutPointBalance)
-
 	// flush new spend outpoints
-	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 newBalances
-	newBalances := make([]*entity.Balance, 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 _, outPoint := range p.newSpendOutPoints {
+			if err := runesDgTx.SpendOutPointBalances(ctx, outPoint, uint64(blockHeader.Height)); err != nil {
+				return errors.Wrap(err, "failed to create spend outpoint")
+			}
 		}
-		for runeId, balance := range balances {
-			newBalances = append(newBalances, &entity.Balance{
-				PkScript:    pkScript,
-				RuneId:      runeId,
-				Amount:      balance,
-				BlockHeight: uint64(blockHeader.Height),
-			})
+		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),
+				})
+			}
 		}
+		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)
 	}
-	if err := runesDgTx.CreateRuneBalances(ctx, newBalances); 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
-	newRuneTxs := p.newRuneTxs
-	if err := runesDgTx.CreateRuneTransactions(ctx, newRuneTxs); err != nil {
-		return errors.Wrap(err, "failed to create rune transaction")
+	{
+		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)
 	}
-	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(newOutpointBalances)),
-		slog.Int("new_spend_outpoints", len(newSpendOutPoints)),
-		slog.Int("new_balances", len(newBalances)),
-		slog.Int("new_rune_txs", len(newRuneTxs)),
-		slogx.Duration("time_taken", timeTaken),
-	)
 
 	// submit event to reporting system
 	if p.reportingClient != nil {
 		if err := p.reportingClient.SubmitBlockReport(ctx, reportingclient.SubmitBlockReportPayload{
 			Type:                "runes",
-			ClientVersion:       constants.Version,
-			DBVersion:           constants.DBVersion,
-			EventHashVersion:    constants.EventHashVersion,
+			ClientVersion:       Version,
+			DBVersion:           DBVersion,
+			EventHashVersion:    EventHashVersion,
 			Network:             p.network,
 			BlockHeight:         uint64(blockHeader.Height),
 			BlockHash:           blockHeader.Hash,

modules/runes/repository/postgres/gen/batch.go

@@ -0,0 +1,130 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.26.0
+// source: batch.go
+
+package gen
+
+import (
+	"context"
+	"errors"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgtype"
+)
+
+var (
+	ErrBatchAlreadyClosed = errors.New("batch already closed")
+)
+
+const createOutPointBalances = `-- 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)
+`
+
+type CreateOutPointBalancesBatchResults struct {
+	br     pgx.BatchResults
+	tot    int
+	closed bool
+}
+
+type CreateOutPointBalancesParams struct {
+	RuneID      string
+	Pkscript    string
+	TxHash      string
+	TxIdx       int32
+	Amount      pgtype.Numeric
+	BlockHeight int32
+	SpentHeight pgtype.Int4
+}
+
+func (q *Queries) CreateOutPointBalances(ctx context.Context, arg []CreateOutPointBalancesParams) *CreateOutPointBalancesBatchResults {
+	batch := &pgx.Batch{}
+	for _, a := range arg {
+		vals := []interface{}{
+			a.RuneID,
+			a.Pkscript,
+			a.TxHash,
+			a.TxIdx,
+			a.Amount,
+			a.BlockHeight,
+			a.SpentHeight,
+		}
+		batch.Queue(createOutPointBalances, vals...)
+	}
+	br := q.db.SendBatch(ctx, batch)
+	return &CreateOutPointBalancesBatchResults{br, len(arg), false}
+}
+
+func (b *CreateOutPointBalancesBatchResults) Exec(f func(int, error)) {
+	defer b.br.Close()
+	for t := 0; t < b.tot; t++ {
+		if b.closed {
+			if f != nil {
+				f(t, ErrBatchAlreadyClosed)
+			}
+			continue
+		}
+		_, err := b.br.Exec()
+		if f != nil {
+			f(t, err)
+		}
+	}
+}
+
+func (b *CreateOutPointBalancesBatchResults) Close() error {
+	b.closed = true
+	return b.br.Close()
+}
+
+const createRuneBalanceAtBlock = `-- name: CreateRuneBalanceAtBlock :batchexec
+INSERT INTO runes_balances (pkscript, block_height, rune_id, amount) VALUES ($1, $2, $3, $4)
+`
+
+type CreateRuneBalanceAtBlockBatchResults struct {
+	br     pgx.BatchResults
+	tot    int
+	closed bool
+}
+
+type CreateRuneBalanceAtBlockParams struct {
+	Pkscript    string
+	BlockHeight int32
+	RuneID      string
+	Amount      pgtype.Numeric
+}
+
+func (q *Queries) CreateRuneBalanceAtBlock(ctx context.Context, arg []CreateRuneBalanceAtBlockParams) *CreateRuneBalanceAtBlockBatchResults {
+	batch := &pgx.Batch{}
+	for _, a := range arg {
+		vals := []interface{}{
+			a.Pkscript,
+			a.BlockHeight,
+			a.RuneID,
+			a.Amount,
+		}
+		batch.Queue(createRuneBalanceAtBlock, vals...)
+	}
+	br := q.db.SendBatch(ctx, batch)
+	return &CreateRuneBalanceAtBlockBatchResults{br, len(arg), false}
+}
+
+func (b *CreateRuneBalanceAtBlockBatchResults) Exec(f func(int, error)) {
+	defer b.br.Close()
+	for t := 0; t < b.tot; t++ {
+		if b.closed {
+			if f != nil {
+				f(t, ErrBatchAlreadyClosed)
+			}
+			continue
+		}
+		_, err := b.br.Exec()
+		if f != nil {
+			f(t, err)
+		}
+	}
+}
+
+func (b *CreateRuneBalanceAtBlockBatchResults) Close() error {
+	b.closed = true
+	return b.br.Close()
+}

modules/runes/repository/postgres/gen/batch.sql.go

@@ -1,319 +0,0 @@
-// Code generated by sqlc. DO NOT EDIT.
-// versions:
-//   sqlc v1.27.0
-// source: batch.sql
-
-package gen
-
-import (
-	"context"
-
-	"github.com/jackc/pgx/v5/pgtype"
-)
-
-const batchCreateRuneEntries = `-- name: BatchCreateRuneEntries :exec
-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(
-  unnest($1::TEXT[]),
-  unnest($2::TEXT[]),
-  unnest($3::BIGINT[]),
-  unnest($4::INT[]),
-  unnest($5::DECIMAL[]),
-  unnest($6::INT[]),
-  unnest($7::SMALLINT[]),
-  unnest($8::BOOLEAN[]),
-  unnest($9::DECIMAL[]),
-  unnest($10::DECIMAL[]),
-  unnest($11::INT[]), -- nullable (need patch)
-  unnest($12::INT[]), -- nullable (need patch)
-  unnest($13::INT[]), -- nullable (need patch)
-  unnest($14::INT[]), -- nullable (need patch)
-  unnest($15::BOOLEAN[]),
-  unnest($16::INT[]),
-  unnest($17::TEXT[]),
-  unnest($18::TIMESTAMP[])
-)
-`
-
-type BatchCreateRuneEntriesParams struct {
-	RuneIDArr           []string
-	RuneArr             []string
-	NumberArr           []int64
-	SpacersArr          []int32
-	PremineArr          []pgtype.Numeric
-	SymbolArr           []int32
-	DivisibilityArr     []int16
-	TermsArr            []bool
-	TermsAmountArr      []pgtype.Numeric
-	TermsCapArr         []pgtype.Numeric
-	TermsHeightStartArr []int32
-	TermsHeightEndArr   []int32
-	TermsOffsetStartArr []int32
-	TermsOffsetEndArr   []int32
-	TurboArr            []bool
-	EtchingBlockArr     []int32
-	EtchingTxHashArr    []string
-	EtchedAtArr         []pgtype.Timestamp
-}
-
-func (q *Queries) BatchCreateRuneEntries(ctx context.Context, arg BatchCreateRuneEntriesParams) error {
-	_, err := q.db.Exec(ctx, batchCreateRuneEntries,
-		arg.RuneIDArr,
-		arg.RuneArr,
-		arg.NumberArr,
-		arg.SpacersArr,
-		arg.PremineArr,
-		arg.SymbolArr,
-		arg.DivisibilityArr,
-		arg.TermsArr,
-		arg.TermsAmountArr,
-		arg.TermsCapArr,
-		arg.TermsHeightStartArr,
-		arg.TermsHeightEndArr,
-		arg.TermsOffsetStartArr,
-		arg.TermsOffsetEndArr,
-		arg.TurboArr,
-		arg.EtchingBlockArr,
-		arg.EtchingTxHashArr,
-		arg.EtchedAtArr,
-	)
-	return err
-}
-
-const batchCreateRuneEntryStates = `-- name: BatchCreateRuneEntryStates :exec
-INSERT INTO runes_entry_states ("rune_id", "block_height", "mints", "burned_amount", "completed_at", "completed_at_height")
-VALUES(
-  unnest($1::TEXT[]),
-  unnest($2::INT[]),
-  unnest($3::DECIMAL[]),
-  unnest($4::DECIMAL[]),
-  unnest($5::TIMESTAMP[]),
-  unnest($6::INT[]) -- nullable (need patch)
-)
-`
-
-type BatchCreateRuneEntryStatesParams struct {
-	RuneIDArr            []string
-	BlockHeightArr       []int32
-	MintsArr             []pgtype.Numeric
-	BurnedAmountArr      []pgtype.Numeric
-	CompletedAtArr       []pgtype.Timestamp
-	CompletedAtHeightArr []int32
-}
-
-func (q *Queries) BatchCreateRuneEntryStates(ctx context.Context, arg BatchCreateRuneEntryStatesParams) error {
-	_, err := q.db.Exec(ctx, batchCreateRuneEntryStates,
-		arg.RuneIDArr,
-		arg.BlockHeightArr,
-		arg.MintsArr,
-		arg.BurnedAmountArr,
-		arg.CompletedAtArr,
-		arg.CompletedAtHeightArr,
-	)
-	return err
-}
-
-const batchCreateRuneTransactions = `-- name: BatchCreateRuneTransactions :exec
-INSERT INTO runes_transactions ("hash", "block_height", "index", "timestamp", "inputs", "outputs", "mints", "burns", "rune_etched")
-VALUES (
-  unnest($1::TEXT[]),
-  unnest($2::INT[]),
-  unnest($3::INT[]),
-  unnest($4::TIMESTAMP[]),
-  unnest($5::JSONB[]),
-  unnest($6::JSONB[]),
-  unnest($7::JSONB[]),
-  unnest($8::JSONB[]),
-  unnest($9::BOOLEAN[])
-)
-`
-
-type BatchCreateRuneTransactionsParams struct {
-	HashArr        []string
-	BlockHeightArr []int32
-	IndexArr       []int32
-	TimestampArr   []pgtype.Timestamp
-	InputsArr      [][]byte
-	OutputsArr     [][]byte
-	MintsArr       [][]byte
-	BurnsArr       [][]byte
-	RuneEtchedArr  []bool
-}
-
-func (q *Queries) BatchCreateRuneTransactions(ctx context.Context, arg BatchCreateRuneTransactionsParams) error {
-	_, err := q.db.Exec(ctx, batchCreateRuneTransactions,
-		arg.HashArr,
-		arg.BlockHeightArr,
-		arg.IndexArr,
-		arg.TimestampArr,
-		arg.InputsArr,
-		arg.OutputsArr,
-		arg.MintsArr,
-		arg.BurnsArr,
-		arg.RuneEtchedArr,
-	)
-	return err
-}
-
-const batchCreateRunesBalances = `-- name: BatchCreateRunesBalances :exec
-INSERT INTO runes_balances ("pkscript", "block_height", "rune_id", "amount")
-VALUES(
-  unnest($1::TEXT[]),
-  unnest($2::INT[]),
-  unnest($3::TEXT[]),
-  unnest($4::DECIMAL[])
-)
-`
-
-type BatchCreateRunesBalancesParams struct {
-	PkscriptArr    []string
-	BlockHeightArr []int32
-	RuneIDArr      []string
-	AmountArr      []pgtype.Numeric
-}
-
-func (q *Queries) BatchCreateRunesBalances(ctx context.Context, arg BatchCreateRunesBalancesParams) error {
-	_, err := q.db.Exec(ctx, batchCreateRunesBalances,
-		arg.PkscriptArr,
-		arg.BlockHeightArr,
-		arg.RuneIDArr,
-		arg.AmountArr,
-	)
-	return err
-}
-
-const batchCreateRunesOutpointBalances = `-- name: BatchCreateRunesOutpointBalances :exec
-INSERT INTO runes_outpoint_balances ("rune_id", "pkscript", "tx_hash", "tx_idx", "amount", "block_height", "spent_height")
-VALUES(
-  unnest($1::TEXT[]),
-  unnest($2::TEXT[]),
-  unnest($3::TEXT[]),
-  unnest($4::INT[]),
-  unnest($5::DECIMAL[]),
-  unnest($6::INT[]),
-  unnest($7::INT[]) -- nullable (need patch)
-)
-`
-
-type BatchCreateRunesOutpointBalancesParams struct {
-	RuneIDArr      []string
-	PkscriptArr    []string
-	TxHashArr      []string
-	TxIdxArr       []int32
-	AmountArr      []pgtype.Numeric
-	BlockHeightArr []int32
-	SpentHeightArr []int32
-}
-
-func (q *Queries) BatchCreateRunesOutpointBalances(ctx context.Context, arg BatchCreateRunesOutpointBalancesParams) error {
-	_, err := q.db.Exec(ctx, batchCreateRunesOutpointBalances,
-		arg.RuneIDArr,
-		arg.PkscriptArr,
-		arg.TxHashArr,
-		arg.TxIdxArr,
-		arg.AmountArr,
-		arg.BlockHeightArr,
-		arg.SpentHeightArr,
-	)
-	return err
-}
-
-const batchCreateRunestones = `-- name: BatchCreateRunestones :exec
-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(
-  unnest($1::TEXT[]),
-  unnest($2::INT[]),
-  unnest($3::BOOLEAN[]),
-  unnest($4::SMALLINT[]), -- nullable (need patch)
-  unnest($5::DECIMAL[]),
-  unnest($6::TEXT[]), -- nullable (need patch)
-  unnest($7::INT[]), -- nullable (need patch)
-  unnest($8::INT[]), -- nullable (need patch)
-  unnest($9::BOOLEAN[]), -- nullable (need patch)
-  unnest($10::DECIMAL[]),
-  unnest($11::DECIMAL[]),
-  unnest($12::INT[]), -- nullable (need patch)
-  unnest($13::INT[]), -- nullable (need patch)
-  unnest($14::INT[]), -- nullable (need patch)
-  unnest($15::INT[]), -- nullable (need patch)
-  unnest($16::BOOLEAN[]), -- nullable (need patch)
-  unnest($17::JSONB[]),
-  unnest($18::TEXT[]), -- nullable (need patch)
-  unnest($19::INT[]), -- nullable (need patch)
-  unnest($20::BOOLEAN[]),
-  unnest($21::INT[])
-)
-`
-
-type BatchCreateRunestonesParams struct {
-	TxHashArr                  []string
-	BlockHeightArr             []int32
-	EtchingArr                 []bool
-	EtchingDivisibilityArr     []int16
-	EtchingPremineArr          []pgtype.Numeric
-	EtchingRuneArr             []string
-	EtchingSpacersArr          []int32
-	EtchingSymbolArr           []int32
-	EtchingTermsArr            []bool
-	EtchingTermsAmountArr      []pgtype.Numeric
-	EtchingTermsCapArr         []pgtype.Numeric
-	EtchingTermsHeightStartArr []int32
-	EtchingTermsHeightEndArr   []int32
-	EtchingTermsOffsetStartArr []int32
-	EtchingTermsOffsetEndArr   []int32
-	EtchingTurboArr            []bool
-	EdictsArr                  [][]byte
-	MintArr                    []string
-	PointerArr                 []int32
-	CenotaphArr                []bool
-	FlawsArr                   []int32
-}
-
-func (q *Queries) BatchCreateRunestones(ctx context.Context, arg BatchCreateRunestonesParams) error {
-	_, err := q.db.Exec(ctx, batchCreateRunestones,
-		arg.TxHashArr,
-		arg.BlockHeightArr,
-		arg.EtchingArr,
-		arg.EtchingDivisibilityArr,
-		arg.EtchingPremineArr,
-		arg.EtchingRuneArr,
-		arg.EtchingSpacersArr,
-		arg.EtchingSymbolArr,
-		arg.EtchingTermsArr,
-		arg.EtchingTermsAmountArr,
-		arg.EtchingTermsCapArr,
-		arg.EtchingTermsHeightStartArr,
-		arg.EtchingTermsHeightEndArr,
-		arg.EtchingTermsOffsetStartArr,
-		arg.EtchingTermsOffsetEndArr,
-		arg.EtchingTurboArr,
-		arg.EdictsArr,
-		arg.MintArr,
-		arg.PointerArr,
-		arg.CenotaphArr,
-		arg.FlawsArr,
-	)
-	return err
-}
-
-const batchSpendOutpointBalances = `-- name: BatchSpendOutpointBalances :exec
-UPDATE runes_outpoint_balances
-	SET "spent_height" = $1::INT
-	FROM (
-    SELECT 
-      unnest($2::TEXT[]) AS tx_hash, 
-      unnest($3::INT[]) AS tx_idx
-    ) AS input
-	WHERE "runes_outpoint_balances"."tx_hash" = "input"."tx_hash" AND "runes_outpoint_balances"."tx_idx" = "input"."tx_idx"
-`
-
-type BatchSpendOutpointBalancesParams struct {
-	SpentHeight int32
-	TxHashArr   []string
-	TxIdxArr    []int32
-}
-
-func (q *Queries) BatchSpendOutpointBalances(ctx context.Context, arg BatchSpendOutpointBalancesParams) error {
-	_, err := q.db.Exec(ctx, batchSpendOutpointBalances, arg.SpentHeight, arg.TxHashArr, arg.TxIdxArr)
-	return err
-}

modules/runes/repository/postgres/gen/batch.sql.patch.go

@@ -1,118 +0,0 @@
-package gen
-
-import (
-	"context"
-
-	"github.com/cockroachdb/errors"
-	"github.com/jackc/pgx/v5/pgtype"
-)
-
-type BatchCreateRuneEntriesPatchedParams struct {
-	BatchCreateRuneEntriesParams
-	TermsHeightStartArr []pgtype.Int4
-	TermsHeightEndArr   []pgtype.Int4
-	TermsOffsetStartArr []pgtype.Int4
-	TermsOffsetEndArr   []pgtype.Int4
-}
-
-func (q *Queries) BatchCreateRuneEntriesPatched(ctx context.Context, arg BatchCreateRuneEntriesPatchedParams) error {
-	_, err := q.db.Exec(ctx, batchCreateRuneEntries,
-		arg.RuneIDArr,
-		arg.RuneArr,
-		arg.NumberArr,
-		arg.SpacersArr,
-		arg.PremineArr,
-		arg.SymbolArr,
-		arg.DivisibilityArr,
-		arg.TermsArr,
-		arg.TermsAmountArr,
-		arg.TermsCapArr,
-		arg.TermsHeightStartArr,
-		arg.TermsHeightEndArr,
-		arg.TermsOffsetStartArr,
-		arg.TermsOffsetEndArr,
-		arg.TurboArr,
-		arg.EtchingBlockArr,
-		arg.EtchingTxHashArr,
-		arg.EtchedAtArr,
-	)
-	return errors.WithStack(err)
-}
-
-type BatchCreateRuneEntryStatesPatchedParams struct {
-	BatchCreateRuneEntryStatesParams
-	CompletedAtHeightArr []pgtype.Int4
-}
-
-func (q *Queries) BatchCreateRuneEntryStatesPatched(ctx context.Context, arg BatchCreateRuneEntryStatesPatchedParams) error {
-	_, err := q.db.Exec(ctx, batchCreateRuneEntryStates,
-		arg.RuneIDArr,
-		arg.BlockHeightArr,
-		arg.MintsArr,
-		arg.BurnedAmountArr,
-		arg.CompletedAtArr,
-		arg.CompletedAtHeightArr,
-	)
-	return errors.WithStack(err)
-}
-
-type BatchCreateRunesOutpointBalancesPatchedParams struct {
-	BatchCreateRunesOutpointBalancesParams
-	SpentHeightArr []pgtype.Int4
-}
-
-func (q *Queries) BatchCreateRunesOutpointBalancesPatched(ctx context.Context, arg BatchCreateRunesOutpointBalancesPatchedParams) error {
-	_, err := q.db.Exec(ctx, batchCreateRunesOutpointBalances,
-		arg.RuneIDArr,
-		arg.PkscriptArr,
-		arg.TxHashArr,
-		arg.TxIdxArr,
-		arg.AmountArr,
-		arg.BlockHeightArr,
-		arg.SpentHeightArr,
-	)
-	return errors.WithStack(err)
-}
-
-type BatchCreateRunestonesPatchedParams struct {
-	BatchCreateRunestonesParams
-	EtchingDivisibilityArr     []pgtype.Int2
-	EtchingRuneArr             []pgtype.Text
-	EtchingSpacersArr          []pgtype.Int4
-	EtchingSymbolArr           []pgtype.Int4
-	EtchingTermsArr            []pgtype.Bool
-	EtchingTermsHeightStartArr []pgtype.Int4
-	EtchingTermsHeightEndArr   []pgtype.Int4
-	EtchingTermsOffsetStartArr []pgtype.Int4
-	EtchingTermsOffsetEndArr   []pgtype.Int4
-	EtchingTurboArr            []pgtype.Bool
-	MintArr                    []pgtype.Text
-	PointerArr                 []pgtype.Int4
-}
-
-func (q *Queries) BatchCreateRunestonesPatched(ctx context.Context, arg BatchCreateRunestonesPatchedParams) error {
-	_, err := q.db.Exec(ctx, batchCreateRunestones,
-		arg.TxHashArr,
-		arg.BlockHeightArr,
-		arg.EtchingArr,
-		arg.EtchingDivisibilityArr,
-		arg.EtchingPremineArr,
-		arg.EtchingRuneArr,
-		arg.EtchingSpacersArr,
-		arg.EtchingSymbolArr,
-		arg.EtchingTermsArr,
-		arg.EtchingTermsAmountArr,
-		arg.EtchingTermsCapArr,
-		arg.EtchingTermsHeightStartArr,
-		arg.EtchingTermsHeightEndArr,
-		arg.EtchingTermsOffsetStartArr,
-		arg.EtchingTermsOffsetEndArr,
-		arg.EtchingTurboArr,
-		arg.EdictsArr,
-		arg.MintArr,
-		arg.PointerArr,
-		arg.CenotaphArr,
-		arg.FlawsArr,
-	)
-	return errors.WithStack(err)
-}

modules/runes/repository/postgres/gen/data.sql.go

@@ -1,6 +1,6 @@
 // Code generated by sqlc. DO NOT EDIT.
 // versions:
-//   sqlc v1.27.0
+//   sqlc v1.26.0
 // source: data.sql
 
 package gen
@@ -45,54 +45,6 @@ func (q *Queries) CreateIndexedBlock(ctx context.Context, arg CreateIndexedBlock
 	return err
 }
 
-const createOutPointBalance = `-- name: CreateOutPointBalance :exec
-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)
-`
-
-type CreateOutPointBalanceParams struct {
-	RuneID      string
-	Pkscript    string
-	TxHash      string
-	TxIdx       int32
-	Amount      pgtype.Numeric
-	BlockHeight int32
-	SpentHeight pgtype.Int4
-}
-
-func (q *Queries) CreateOutPointBalance(ctx context.Context, arg CreateOutPointBalanceParams) error {
-	_, err := q.db.Exec(ctx, createOutPointBalance,
-		arg.RuneID,
-		arg.Pkscript,
-		arg.TxHash,
-		arg.TxIdx,
-		arg.Amount,
-		arg.BlockHeight,
-		arg.SpentHeight,
-	)
-	return err
-}
-
-const createRuneBalance = `-- name: CreateRuneBalance :exec
-INSERT INTO runes_balances (pkscript, block_height, rune_id, amount) VALUES ($1, $2, $3, $4)
-`
-
-type CreateRuneBalanceParams struct {
-	Pkscript    string
-	BlockHeight int32
-	RuneID      string
-	Amount      pgtype.Numeric
-}
-
-func (q *Queries) CreateRuneBalance(ctx context.Context, arg CreateRuneBalanceParams) error {
-	_, err := q.db.Exec(ctx, createRuneBalance,
-		arg.Pkscript,
-		arg.BlockHeight,
-		arg.RuneID,
-		arg.Amount,
-	)
-	return err
-}
-
 const createRuneEntry = `-- name: CreateRuneEntry :exec
 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)
@@ -344,14 +296,12 @@ const getBalancesByPkScript = `-- name: GetBalancesByPkScript :many
 WITH balances AS (
   SELECT DISTINCT ON (rune_id) pkscript, block_height, rune_id, amount FROM runes_balances WHERE pkscript = $1 AND block_height <= $2 ORDER BY rune_id, block_height DESC
 )
-SELECT pkscript, block_height, rune_id, amount FROM balances WHERE amount > 0 ORDER BY amount DESC, rune_id LIMIT $3 OFFSET $4
+SELECT pkscript, block_height, rune_id, amount FROM balances WHERE amount > 0
 `
 
 type GetBalancesByPkScriptParams struct {
 	Pkscript    string
 	BlockHeight int32
-	Limit       int32
-	Offset      int32
 }
 
 type GetBalancesByPkScriptRow struct {
@@ -362,12 +312,7 @@ type GetBalancesByPkScriptRow struct {
 }
 
 func (q *Queries) GetBalancesByPkScript(ctx context.Context, arg GetBalancesByPkScriptParams) ([]GetBalancesByPkScriptRow, error) {
-	rows, err := q.db.Query(ctx, getBalancesByPkScript,
-		arg.Pkscript,
-		arg.BlockHeight,
-		arg.Limit,
-		arg.Offset,
-	)
+	rows, err := q.db.Query(ctx, getBalancesByPkScript, arg.Pkscript, arg.BlockHeight)
 	if err != nil {
 		return nil, err
 	}
@@ -395,14 +340,12 @@ const getBalancesByRuneId = `-- name: GetBalancesByRuneId :many
 WITH balances AS (
   SELECT DISTINCT ON (pkscript) pkscript, block_height, rune_id, amount FROM runes_balances WHERE rune_id = $1 AND block_height <= $2 ORDER BY pkscript, block_height DESC
 )
-SELECT pkscript, block_height, rune_id, amount FROM balances WHERE amount > 0 ORDER BY amount DESC, pkscript LIMIT $3 OFFSET $4
+SELECT pkscript, block_height, rune_id, amount FROM balances WHERE amount > 0
 `
 
 type GetBalancesByRuneIdParams struct {
 	RuneID      string
 	BlockHeight int32
-	Limit       int32
-	Offset      int32
 }
 
 type GetBalancesByRuneIdRow struct {
@@ -413,12 +356,7 @@ type GetBalancesByRuneIdRow struct {
 }
 
 func (q *Queries) GetBalancesByRuneId(ctx context.Context, arg GetBalancesByRuneIdParams) ([]GetBalancesByRuneIdRow, error) {
-	rows, err := q.db.Query(ctx, getBalancesByRuneId,
-		arg.RuneID,
-		arg.BlockHeight,
-		arg.Limit,
-		arg.Offset,
-	)
+	rows, err := q.db.Query(ctx, getBalancesByRuneId, arg.RuneID, arg.BlockHeight)
 	if err != nil {
 		return nil, err
 	}
@@ -476,120 +414,6 @@ func (q *Queries) GetLatestIndexedBlock(ctx context.Context) (RunesIndexedBlock,
 	return i, err
 }
 
-const getOngoingRuneEntries = `-- name: GetOngoingRuneEntries :many
-WITH states AS (
-  -- select latest state
-  SELECT DISTINCT ON (rune_id) rune_id, block_height, mints, burned_amount, completed_at, completed_at_height FROM runes_entry_states WHERE block_height <= $1::integer ORDER BY rune_id, block_height DESC
-)
-SELECT runes_entries.rune_id, number, rune, 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, states.rune_id, block_height, mints, burned_amount, completed_at, completed_at_height FROM runes_entries 
-  LEFT JOIN states ON runes_entries.rune_id = states.rune_id
-  WHERE (
-    runes_entries.terms = TRUE AND
-    COALESCE(runes_entries.terms_amount, 0) != 0 AND
-    COALESCE(runes_entries.terms_cap, 0) != 0 AND
-    states.mints < runes_entries.terms_cap AND
-    (
-      runes_entries.terms_height_start IS NULL OR runes_entries.terms_height_start <= $1::integer
-    ) AND (
-      runes_entries.terms_height_end IS NULL OR $1::integer <= runes_entries.terms_height_end
-    ) AND (
-      runes_entries.terms_offset_start IS NULL OR runes_entries.terms_offset_start + runes_entries.etching_block <= $1::integer
-    ) AND (
-      runes_entries.terms_offset_end IS NULL OR $1::integer <= runes_entries.terms_offset_start + runes_entries.etching_block
-    )
-
-  ) AND (
-    $2::text = '' OR
-    runes_entries.rune ILIKE '%' || $2::text || '%'
-  )
-  ORDER BY states.mints DESC
-  LIMIT $4 OFFSET $3
-`
-
-type GetOngoingRuneEntriesParams struct {
-	Height int32
-	Search string
-	Offset int32
-	Limit  int32
-}
-
-type GetOngoingRuneEntriesRow struct {
-	RuneID            string
-	Number            int64
-	Rune              string
-	Spacers           int32
-	Premine           pgtype.Numeric
-	Symbol            int32
-	Divisibility      int16
-	Terms             bool
-	TermsAmount       pgtype.Numeric
-	TermsCap          pgtype.Numeric
-	TermsHeightStart  pgtype.Int4
-	TermsHeightEnd    pgtype.Int4
-	TermsOffsetStart  pgtype.Int4
-	TermsOffsetEnd    pgtype.Int4
-	Turbo             bool
-	EtchingBlock      int32
-	EtchingTxHash     string
-	EtchedAt          pgtype.Timestamp
-	RuneID_2          pgtype.Text
-	BlockHeight       pgtype.Int4
-	Mints             pgtype.Numeric
-	BurnedAmount      pgtype.Numeric
-	CompletedAt       pgtype.Timestamp
-	CompletedAtHeight pgtype.Int4
-}
-
-func (q *Queries) GetOngoingRuneEntries(ctx context.Context, arg GetOngoingRuneEntriesParams) ([]GetOngoingRuneEntriesRow, error) {
-	rows, err := q.db.Query(ctx, getOngoingRuneEntries,
-		arg.Height,
-		arg.Search,
-		arg.Offset,
-		arg.Limit,
-	)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var items []GetOngoingRuneEntriesRow
-	for rows.Next() {
-		var i GetOngoingRuneEntriesRow
-		if err := rows.Scan(
-			&i.RuneID,
-			&i.Number,
-			&i.Rune,
-			&i.Spacers,
-			&i.Premine,
-			&i.Symbol,
-			&i.Divisibility,
-			&i.Terms,
-			&i.TermsAmount,
-			&i.TermsCap,
-			&i.TermsHeightStart,
-			&i.TermsHeightEnd,
-			&i.TermsOffsetStart,
-			&i.TermsOffsetEnd,
-			&i.Turbo,
-			&i.EtchingBlock,
-			&i.EtchingTxHash,
-			&i.EtchedAt,
-			&i.RuneID_2,
-			&i.BlockHeight,
-			&i.Mints,
-			&i.BurnedAmount,
-			&i.CompletedAt,
-			&i.CompletedAtHeight,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
 const getOutPointBalancesAtOutPoint = `-- name: GetOutPointBalancesAtOutPoint :many
 SELECT rune_id, pkscript, tx_hash, tx_idx, amount, block_height, spent_height FROM runes_outpoint_balances WHERE tx_hash = $1 AND tx_idx = $2
 `
@@ -627,105 +451,6 @@ func (q *Queries) GetOutPointBalancesAtOutPoint(ctx context.Context, arg GetOutP
 	return items, nil
 }
 
-const getRuneEntries = `-- name: GetRuneEntries :many
-WITH states AS (
-  -- select latest state
-  SELECT DISTINCT ON (rune_id) rune_id, block_height, mints, burned_amount, completed_at, completed_at_height FROM runes_entry_states WHERE block_height <= $4 ORDER BY rune_id, block_height DESC
-)
-SELECT runes_entries.rune_id, number, rune, 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, states.rune_id, block_height, mints, burned_amount, completed_at, completed_at_height FROM runes_entries 
-  LEFT JOIN states ON runes_entries.rune_id = states.rune_id
-  WHERE (
-    $1 = '' OR
-    runes_entries.rune ILIKE $1 || '%'
-  )
-  ORDER BY runes_entries.number 
-  LIMIT $3 OFFSET $2
-`
-
-type GetRuneEntriesParams struct {
-	Search interface{}
-	Offset int32
-	Limit  int32
-	Height int32
-}
-
-type GetRuneEntriesRow struct {
-	RuneID            string
-	Number            int64
-	Rune              string
-	Spacers           int32
-	Premine           pgtype.Numeric
-	Symbol            int32
-	Divisibility      int16
-	Terms             bool
-	TermsAmount       pgtype.Numeric
-	TermsCap          pgtype.Numeric
-	TermsHeightStart  pgtype.Int4
-	TermsHeightEnd    pgtype.Int4
-	TermsOffsetStart  pgtype.Int4
-	TermsOffsetEnd    pgtype.Int4
-	Turbo             bool
-	EtchingBlock      int32
-	EtchingTxHash     string
-	EtchedAt          pgtype.Timestamp
-	RuneID_2          pgtype.Text
-	BlockHeight       pgtype.Int4
-	Mints             pgtype.Numeric
-	BurnedAmount      pgtype.Numeric
-	CompletedAt       pgtype.Timestamp
-	CompletedAtHeight pgtype.Int4
-}
-
-func (q *Queries) GetRuneEntries(ctx context.Context, arg GetRuneEntriesParams) ([]GetRuneEntriesRow, error) {
-	rows, err := q.db.Query(ctx, getRuneEntries,
-		arg.Search,
-		arg.Offset,
-		arg.Limit,
-		arg.Height,
-	)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var items []GetRuneEntriesRow
-	for rows.Next() {
-		var i GetRuneEntriesRow
-		if err := rows.Scan(
-			&i.RuneID,
-			&i.Number,
-			&i.Rune,
-			&i.Spacers,
-			&i.Premine,
-			&i.Symbol,
-			&i.Divisibility,
-			&i.Terms,
-			&i.TermsAmount,
-			&i.TermsCap,
-			&i.TermsHeightStart,
-			&i.TermsHeightEnd,
-			&i.TermsOffsetStart,
-			&i.TermsOffsetEnd,
-			&i.Turbo,
-			&i.EtchingBlock,
-			&i.EtchingTxHash,
-			&i.EtchedAt,
-			&i.RuneID_2,
-			&i.BlockHeight,
-			&i.Mints,
-			&i.BurnedAmount,
-			&i.CompletedAt,
-			&i.CompletedAtHeight,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
 const getRuneEntriesByRuneIds = `-- name: GetRuneEntriesByRuneIds :many
 WITH states AS (
   -- select latest state
@@ -906,106 +631,26 @@ func (q *Queries) GetRuneIdFromRune(ctx context.Context, rune string) (string, e
 	return rune_id, err
 }
 
-const getRuneTransaction = `-- name: GetRuneTransaction :one
-SELECT hash, runes_transactions.block_height, index, timestamp, inputs, outputs, mints, burns, rune_etched, tx_hash, runes_runestones.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 FROM runes_transactions
-  LEFT JOIN runes_runestones ON runes_transactions.hash = runes_runestones.tx_hash
-  WHERE hash = $1 LIMIT 1
-`
-
-type GetRuneTransactionRow struct {
-	Hash                    string
-	BlockHeight             int32
-	Index                   int32
-	Timestamp               pgtype.Timestamp
-	Inputs                  []byte
-	Outputs                 []byte
-	Mints                   []byte
-	Burns                   []byte
-	RuneEtched              bool
-	TxHash                  pgtype.Text
-	BlockHeight_2           pgtype.Int4
-	Etching                 pgtype.Bool
-	EtchingDivisibility     pgtype.Int2
-	EtchingPremine          pgtype.Numeric
-	EtchingRune             pgtype.Text
-	EtchingSpacers          pgtype.Int4
-	EtchingSymbol           pgtype.Int4
-	EtchingTerms            pgtype.Bool
-	EtchingTermsAmount      pgtype.Numeric
-	EtchingTermsCap         pgtype.Numeric
-	EtchingTermsHeightStart pgtype.Int4
-	EtchingTermsHeightEnd   pgtype.Int4
-	EtchingTermsOffsetStart pgtype.Int4
-	EtchingTermsOffsetEnd   pgtype.Int4
-	EtchingTurbo            pgtype.Bool
-	Edicts                  []byte
-	Mint                    pgtype.Text
-	Pointer                 pgtype.Int4
-	Cenotaph                pgtype.Bool
-	Flaws                   pgtype.Int4
-}
-
-func (q *Queries) GetRuneTransaction(ctx context.Context, hash string) (GetRuneTransactionRow, error) {
-	row := q.db.QueryRow(ctx, getRuneTransaction, hash)
-	var i GetRuneTransactionRow
-	err := row.Scan(
-		&i.Hash,
-		&i.BlockHeight,
-		&i.Index,
-		&i.Timestamp,
-		&i.Inputs,
-		&i.Outputs,
-		&i.Mints,
-		&i.Burns,
-		&i.RuneEtched,
-		&i.TxHash,
-		&i.BlockHeight_2,
-		&i.Etching,
-		&i.EtchingDivisibility,
-		&i.EtchingPremine,
-		&i.EtchingRune,
-		&i.EtchingSpacers,
-		&i.EtchingSymbol,
-		&i.EtchingTerms,
-		&i.EtchingTermsAmount,
-		&i.EtchingTermsCap,
-		&i.EtchingTermsHeightStart,
-		&i.EtchingTermsHeightEnd,
-		&i.EtchingTermsOffsetStart,
-		&i.EtchingTermsOffsetEnd,
-		&i.EtchingTurbo,
-		&i.Edicts,
-		&i.Mint,
-		&i.Pointer,
-		&i.Cenotaph,
-		&i.Flaws,
-	)
-	return i, err
-}
-
 const getRuneTransactions = `-- name: GetRuneTransactions :many
 SELECT hash, runes_transactions.block_height, index, timestamp, inputs, outputs, mints, burns, rune_etched, tx_hash, runes_runestones.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 FROM runes_transactions
 	LEFT JOIN runes_runestones ON runes_transactions.hash = runes_runestones.tx_hash
 	WHERE (
-    $3::BOOLEAN = FALSE -- if @filter_pk_script is TRUE, apply pk_script filter
+    $1::BOOLEAN = FALSE -- if @filter_pk_script is TRUE, apply pk_script filter
+    OR runes_transactions.outputs @> $2::JSONB 
+    OR runes_transactions.inputs @> $2::JSONB
+  ) AND (
+    $3::BOOLEAN = FALSE -- if @filter_rune_id is TRUE, apply rune_id filter
     OR runes_transactions.outputs @> $4::JSONB 
-    OR runes_transactions.inputs @> $4::JSONB
+    OR runes_transactions.inputs @> $4::JSONB 
+    OR runes_transactions.mints ? $5 
+    OR runes_transactions.burns ? $5
+    OR (runes_transactions.rune_etched = TRUE AND runes_transactions.block_height = $6 AND runes_transactions.index = $7)
   ) AND (
-    $5::BOOLEAN = FALSE -- if @filter_rune_id is TRUE, apply rune_id filter
-    OR runes_transactions.outputs @> $6::JSONB 
-    OR runes_transactions.inputs @> $6::JSONB 
-    OR runes_transactions.mints ? $7 
-    OR runes_transactions.burns ? $7
-    OR (runes_transactions.rune_etched = TRUE AND runes_transactions.block_height = $8 AND runes_transactions.index = $9)
-  ) AND (
-    $10 <= runes_transactions.block_height AND runes_transactions.block_height <= $11
+    $8::INT = 0 OR runes_transactions.block_height = $8::INT -- if @block_height > 0, apply block_height filter
   )
-ORDER BY runes_transactions.block_height DESC, runes_transactions.index DESC LIMIT $1 OFFSET $2
 `
 
 type GetRuneTransactionsParams struct {
-	Limit             int32
-	Offset            int32
 	FilterPkScript    bool
 	PkScriptParam     []byte
 	FilterRuneID      bool
@@ -1013,8 +658,7 @@ type GetRuneTransactionsParams struct {
 	RuneID            []byte
 	RuneIDBlockHeight int32
 	RuneIDTxIndex     int32
-	FromBlock         int32
-	ToBlock           int32
+	BlockHeight       int32
 }
 
 type GetRuneTransactionsRow struct {
@@ -1052,8 +696,6 @@ type GetRuneTransactionsRow struct {
 
 func (q *Queries) GetRuneTransactions(ctx context.Context, arg GetRuneTransactionsParams) ([]GetRuneTransactionsRow, error) {
 	rows, err := q.db.Query(ctx, getRuneTransactions,
-		arg.Limit,
-		arg.Offset,
 		arg.FilterPkScript,
 		arg.PkScriptParam,
 		arg.FilterRuneID,
@@ -1061,8 +703,7 @@ func (q *Queries) GetRuneTransactions(ctx context.Context, arg GetRuneTransactio
 		arg.RuneID,
 		arg.RuneIDBlockHeight,
 		arg.RuneIDTxIndex,
-		arg.FromBlock,
-		arg.ToBlock,
+		arg.BlockHeight,
 	)
 	if err != nil {
 		return nil, err
@@ -1113,53 +754,32 @@ func (q *Queries) GetRuneTransactions(ctx context.Context, arg GetRuneTransactio
 	return items, nil
 }
 
-const getRunesUTXOsByPkScript = `-- name: GetRunesUTXOsByPkScript :many
-SELECT tx_hash, tx_idx, max("pkscript") as pkscript, array_agg("rune_id") as rune_ids, array_agg("amount") as amounts 
-  FROM runes_outpoint_balances 
-  WHERE
-    pkscript = $3 AND
-    block_height <= $4 AND
-    (spent_height IS NULL OR spent_height > $4)
-  GROUP BY tx_hash, tx_idx
-  ORDER BY tx_hash, tx_idx 
-  LIMIT $1 OFFSET $2
+const getUnspentOutPointBalancesByPkScript = `-- name: GetUnspentOutPointBalancesByPkScript :many
+SELECT rune_id, pkscript, tx_hash, tx_idx, amount, block_height, spent_height FROM runes_outpoint_balances WHERE pkscript = $1 AND block_height <= $2 AND (spent_height IS NULL OR spent_height > $2)
 `
 
-type GetRunesUTXOsByPkScriptParams struct {
-	Limit       int32
-	Offset      int32
+type GetUnspentOutPointBalancesByPkScriptParams struct {
 	Pkscript    string
 	BlockHeight int32
 }
 
-type GetRunesUTXOsByPkScriptRow struct {
-	TxHash   string
-	TxIdx    int32
-	Pkscript interface{}
-	RuneIds  interface{}
-	Amounts  interface{}
-}
-
-func (q *Queries) GetRunesUTXOsByPkScript(ctx context.Context, arg GetRunesUTXOsByPkScriptParams) ([]GetRunesUTXOsByPkScriptRow, error) {
-	rows, err := q.db.Query(ctx, getRunesUTXOsByPkScript,
-		arg.Limit,
-		arg.Offset,
-		arg.Pkscript,
-		arg.BlockHeight,
-	)
+func (q *Queries) GetUnspentOutPointBalancesByPkScript(ctx context.Context, arg GetUnspentOutPointBalancesByPkScriptParams) ([]RunesOutpointBalance, error) {
+	rows, err := q.db.Query(ctx, getUnspentOutPointBalancesByPkScript, arg.Pkscript, arg.BlockHeight)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-	var items []GetRunesUTXOsByPkScriptRow
+	var items []RunesOutpointBalance
 	for rows.Next() {
-		var i GetRunesUTXOsByPkScriptRow
+		var i RunesOutpointBalance
 		if err := rows.Scan(
+			&i.RuneID,
+			&i.Pkscript,
 			&i.TxHash,
 			&i.TxIdx,
-			&i.Pkscript,
-			&i.RuneIds,
-			&i.Amounts,
+			&i.Amount,
+			&i.BlockHeight,
+			&i.SpentHeight,
 		); err != nil {
 			return nil, err
 		}
@@ -1171,116 +791,18 @@ func (q *Queries) GetRunesUTXOsByPkScript(ctx context.Context, arg GetRunesUTXOs
 	return items, nil
 }
 
-const getRunesUTXOsByRuneIdAndPkScript = `-- name: GetRunesUTXOsByRuneIdAndPkScript :many
-SELECT tx_hash, tx_idx, max("pkscript") as pkscript, array_agg("rune_id") as rune_ids, array_agg("amount") as amounts 
-  FROM runes_outpoint_balances 
-  WHERE
-    pkscript = $3 AND 
-    block_height <= $4 AND 
-    (spent_height IS NULL OR spent_height > $4)
-  GROUP BY tx_hash, tx_idx
-  HAVING array_agg("rune_id") @> $5::text[] 
-  ORDER BY tx_hash, tx_idx 
-  LIMIT $1 OFFSET $2
-`
-
-type GetRunesUTXOsByRuneIdAndPkScriptParams struct {
-	Limit       int32
-	Offset      int32
-	Pkscript    string
-	BlockHeight int32
-	RuneIds     []string
-}
-
-type GetRunesUTXOsByRuneIdAndPkScriptRow struct {
-	TxHash   string
-	TxIdx    int32
-	Pkscript interface{}
-	RuneIds  interface{}
-	Amounts  interface{}
-}
-
-func (q *Queries) GetRunesUTXOsByRuneIdAndPkScript(ctx context.Context, arg GetRunesUTXOsByRuneIdAndPkScriptParams) ([]GetRunesUTXOsByRuneIdAndPkScriptRow, error) {
-	rows, err := q.db.Query(ctx, getRunesUTXOsByRuneIdAndPkScript,
-		arg.Limit,
-		arg.Offset,
-		arg.Pkscript,
-		arg.BlockHeight,
-		arg.RuneIds,
-	)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var items []GetRunesUTXOsByRuneIdAndPkScriptRow
-	for rows.Next() {
-		var i GetRunesUTXOsByRuneIdAndPkScriptRow
-		if err := rows.Scan(
-			&i.TxHash,
-			&i.TxIdx,
-			&i.Pkscript,
-			&i.RuneIds,
-			&i.Amounts,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const getTotalHoldersByRuneIds = `-- name: GetTotalHoldersByRuneIds :many
-WITH balances AS (
-  SELECT DISTINCT ON (rune_id, pkscript) pkscript, block_height, rune_id, amount FROM runes_balances WHERE rune_id = ANY($1::TEXT[]) AND block_height <= $2 ORDER BY rune_id, pkscript, block_height DESC
-)
-SELECT rune_id, COUNT(DISTINCT pkscript) FROM balances WHERE amount > 0 GROUP BY rune_id
-`
-
-type GetTotalHoldersByRuneIdsParams struct {
-	RuneIds     []string
-	BlockHeight int32
-}
-
-type GetTotalHoldersByRuneIdsRow struct {
-	RuneID string
-	Count  int64
-}
-
-func (q *Queries) GetTotalHoldersByRuneIds(ctx context.Context, arg GetTotalHoldersByRuneIdsParams) ([]GetTotalHoldersByRuneIdsRow, error) {
-	rows, err := q.db.Query(ctx, getTotalHoldersByRuneIds, arg.RuneIds, arg.BlockHeight)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var items []GetTotalHoldersByRuneIdsRow
-	for rows.Next() {
-		var i GetTotalHoldersByRuneIdsRow
-		if err := rows.Scan(&i.RuneID, &i.Count); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const spendOutPointBalance = `-- name: SpendOutPointBalance :exec
+const spendOutPointBalances = `-- name: SpendOutPointBalances :exec
 UPDATE runes_outpoint_balances SET spent_height = $1 WHERE tx_hash = $2 AND tx_idx = $3
 `
 
-type SpendOutPointBalanceParams struct {
+type SpendOutPointBalancesParams struct {
 	SpentHeight pgtype.Int4
 	TxHash      string
 	TxIdx       int32
 }
 
-func (q *Queries) SpendOutPointBalance(ctx context.Context, arg SpendOutPointBalanceParams) error {
-	_, err := q.db.Exec(ctx, spendOutPointBalance, arg.SpentHeight, arg.TxHash, arg.TxIdx)
+func (q *Queries) SpendOutPointBalances(ctx context.Context, arg SpendOutPointBalancesParams) error {
+	_, err := q.db.Exec(ctx, spendOutPointBalances, arg.SpentHeight, arg.TxHash, arg.TxIdx)
 	return err
 }
 

modules/runes/repository/postgres/gen/db.go

@@ -1,6 +1,6 @@
 // Code generated by sqlc. DO NOT EDIT.
 // versions:
-//   sqlc v1.27.0
+//   sqlc v1.26.0
 
 package gen
 
@@ -15,6 +15,7 @@ type DBTX interface {
 	Exec(context.Context, string, ...interface{}) (pgconn.CommandTag, error)
 	Query(context.Context, string, ...interface{}) (pgx.Rows, error)
 	QueryRow(context.Context, string, ...interface{}) pgx.Row
+	SendBatch(context.Context, *pgx.Batch) pgx.BatchResults
 }
 
 func New(db DBTX) *Queries {

modules/runes/repository/postgres/gen/info.sql.go

@@ -1,6 +1,6 @@
 // Code generated by sqlc. DO NOT EDIT.
 // versions:
-//   sqlc v1.27.0
+//   sqlc v1.26.0
 // source: info.sql
 
 package gen