fix: handle block timeout = 0

* feat: add with request headers config

* feat: add with fields config

* feat: format request queries

.dockerignore

@@ -0,0 +1,18 @@
+.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,6 +58,9 @@ 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 ./...
 

Dockerfile

@@ -3,15 +3,15 @@ FROM golang:1.22 as builder
 WORKDIR /app
 
 COPY go.mod go.sum ./
-RUN go mod download
+RUN --mount=type=cache,target=/go/pkg/mod/ go mod download
 
 COPY ./ ./
 
 ENV GOOS=linux
 ENV CGO_ENABLED=0
 
-RUN go build \
-          -o main ./main.go
+RUN --mount=type=cache,target=/go/pkg/mod/ \
+    go build -o main ./main.go
 
 FROM alpine:latest
 
@@ -19,9 +19,10 @@ 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` environment variable to change the timezone
+# 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
 
-CMD ["/app/main", "run"]
+ENTRYPOINT ["/app/main"]

README.md

@@ -2,18 +2,15 @@
 
 # Gaze Indexer
 
-Gaze Indexer is an open-source and modular indexing client for Bitcoin meta-protocols. It has support for Bitcoin and Runes out of the box, with **Unified Consistent APIs** across fungible token protocols.
+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 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.
 
 Gaze Indexer serves as a foundation for building ANY meta-protocol indexers, with efficient data fetching, reorg detection, and database migration tool.
 This allows developers to focus on what **truly** matters: Meta-protocol indexing logic. New meta-protocols can be easily added by implementing new modules.
 
-Gaze Indexer also comes with a block reporting system for verifying data integrity of indexers. Visit the [Gaze Network dashboard](https://dash.gaze.network) to see the status of other indexers.
-
 - [Modules](#modules)
-  - [1. Bitcoin](#1-bitcoin)
-  - [2. Runes](#2-runes)
+  - [1. Runes](#1-runes)
 - [Installation](#installation)
   - [Prerequisites](#prerequisites)
     - [1. Hardware Requirements](#1-hardware-requirements)
@@ -25,15 +22,10 @@ Gaze Indexer also comes with a block reporting system for verifying data integri
 
 ## Modules
 
-### 1. Bitcoin
-
-The Bitcoin Indexer, the heart of every meta-protocol, is responsible for indexing **Bitcoin transactions, blocks, and UTXOs**. It requires a Bitcoin Core RPC as source of Bitcoin transactions,
-and stores the indexed data in database to be used by other modules.
-
-### 2. Runes
+### 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://documenter.getpostman.com/view/28396285/2sA3Bn7Cxr) for full details.
+It comes with a set of APIs for querying historical Runes data. See our [API Reference](https://api-docs.gaze.network) for full details.
 
 ## Installation
 
@@ -42,10 +34,9 @@ It comes with a set of APIs for querying historical Runes data. See our [API Ref
 #### 1. Hardware Requirements
 
 Each module requires different hardware requirements.
-| Module | CPU | RAM |
-| ------- | ---------- | ------ |
-| Bitcoin | 0.25 cores | 256 MB |
-| Runes | 0.5 cores | 1 GB |
+| Module | CPU       | RAM  |
+| ------ | --------- | ---- |
+| Runes  | 0.5 cores | 1 GB |
 
 #### 2. Prepare Bitcoin Core RPC server.
 
@@ -56,10 +47,9 @@ To self host a Bitcoin Core, see https://bitcoin.org/en/full-node.
 
 Gaze Indexer has first-class support for PostgreSQL. If you wish to use other databases, you can implement your own database repository that satisfies each module's Data Gateway interface.
 Here is our minimum database disk space requirement for each module.
-| Module | Database Storage |
-| ------- | ---------------- |
-| Bitcoin | 240 GB |
-| Runes | 150 GB |
+| Module | Database Storage (current) | Database Storage (in 1 year) |
+| ------ | -------------------------- | ---------------------------- |
+| Runes  | 10 GB                      | 150 GB                       |
 
 #### 4. Prepare `config.yaml` file.
 
@@ -93,21 +83,10 @@ http_server:
 
 # Meta-protocol modules configuration options.
 modules:
-  # Configuration options for Bitcoin module. Can be removed if not used.
-  bitcoin:
-    database: "postgres" # Database to store bitcoin data. current supported databases: "postgres"
-    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.
-
   # Configuration options for Runes module. Can be removed if not used.
   runes:
     database: "postgres" # Database to store Runes data. current supported databases: "postgres"
-    datasource: "database" # Data source to be used for Bitcoin data. current supported data sources: "bitcoin-node" | "database". If "database" is used, it will use the database config in bitcoin module as datasource.
+    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:
@@ -127,14 +106,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:v1.0.0
+    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", "--bitcoin", "--runes"] # Put module flags after "run" commands to select which modules to run.
+    command: ["/app/main", "run", "--modules", "runes"] # Put module flags after "run" commands to select which modules to run.
 ```
 
 ### Install from source
@@ -160,17 +139,17 @@ go build -o gaze main.go
 4. Run database migrations with the `migrate` command and module flags.
 
 ```bash
-./gaze migrate up --bitcoin --runes --database postgres://postgres:password@localhost:5432/postgres
+./gaze migrate up --runes --database postgres://postgres:password@localhost:5432/postgres
 ```
 
 5. Start the indexer with the `run` command and module flags.
 
 ```bash
-./gaze run --bitcoin --runes
+./gaze run --modules runes
 ```
 
 If `config.yaml` is not located at `./app/config.yaml`, use the `--config` flag to specify the path to the `config.yaml` file.
 
 ```bash
-./gaze run --bitcoin --runes --config /path/to/config.yaml
+./gaze run --modules runes --config /path/to/config.yaml
 ```

cmd/cmd_run.go

@@ -15,79 +15,67 @@ import (
 	"github.com/btcsuite/btcd/rpcclient"
 	"github.com/cockroachdb/errors"
 	"github.com/gaze-network/indexer-network/common/errs"
-	"github.com/gaze-network/indexer-network/core/datasources"
-	"github.com/gaze-network/indexer-network/core/indexers"
+	"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/bitcoin"
-	"github.com/gaze-network/indexer-network/modules/bitcoin/btcclient"
-	btcdatagateway "github.com/gaze-network/indexer-network/modules/bitcoin/datagateway"
-	btcpostgres "github.com/gaze-network/indexer-network/modules/bitcoin/repository/postgres"
+	"github.com/gaze-network/indexer-network/modules/nodesale"
 	"github.com/gaze-network/indexer-network/modules/runes"
-	runesapi "github.com/gaze-network/indexer-network/modules/runes/api"
-	runesdatagateway "github.com/gaze-network/indexer-network/modules/runes/datagateway"
-	runespostgres "github.com/gaze-network/indexer-network/modules/runes/repository/postgres"
-	runesusecase "github.com/gaze-network/indexer-network/modules/runes/usecase"
-	"github.com/gaze-network/indexer-network/pkg/errorhandler"
+	"github.com/gaze-network/indexer-network/pkg/automaxprocs"
 	"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"
 )
 
-const (
-	shutdownTimeout = 60 * time.Second
+// Register Modules
+var Modules = do.Package(
+	do.LazyNamed("runes", runes.New),
+	do.LazyNamed("nodesale", nodesale.New),
 )
 
-type runCmdOptions struct {
-	APIOnly bool
-	Bitcoin bool
-	Runes   bool
-}
-
 func NewRunCommand() *cobra.Command {
-	opts := &runCmdOptions{}
-
 	// Create command
 	runCmd := &cobra.Command{
 		Use:   "run",
 		Short: "Start indexer-network service",
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return runHandler(opts, cmd, args)
+			if err := automaxprocs.Init(); err != nil {
+				logger.Error("Failed to set GOMAXPROCS", slogx.Error(err))
+			}
+			return runHandler(cmd, args)
 		},
 	}
 
-	// TODO: separate flags and bind flags to each module cmd package.
-
 	// Add local flags
 	flags := runCmd.Flags()
-	flags.BoolVar(&opts.APIOnly, "api-only", false, "Run only API server")
-	flags.BoolVar(&opts.Bitcoin, "bitcoin", false, "Enable Bitcoin indexer module")
-	flags.String("bitcoin-db", "postgres", `Database to store bitcoin data. current supported databases: "postgres"`)
-	flags.BoolVar(&opts.Runes, "runes", false, "Enable Runes indexer module")
-	flags.String("runes-db", "postgres", `Database to store runes data. current supported databases: "postgres"`)
-	flags.String("runes-datasource", "bitcoin-node", `Datasource to fetch bitcoin data for processing Meta-Protocol data. current supported datasources: "bitcoin-node" | "database"`)
+	flags.Bool("api-only", false, "Run only API server")
+	flags.String("modules", "", "Enable specific modules to run. E.g. `runes,brc20`")
 
 	// Bind flags to configuration
-	config.BindPFlag("modules.bitcoin.database", flags.Lookup("bitcoin-db"))
-	config.BindPFlag("modules.runes.database", flags.Lookup("runes-db"))
-	config.BindPFlag("modules.runes.datasource", flags.Lookup("runes-datasource"))
+	config.BindPFlag("api_only", flags.Lookup("api-only"))
+	config.BindPFlag("enable_modules", flags.Lookup("modules"))
 
 	return runCmd
 }
 
-type HttpHandler interface {
-	Mount(router fiber.Router) error
-}
+const (
+	shutdownTimeout = 60 * time.Second
+)
 
-func runHandler(opts *runCmdOptions, cmd *cobra.Command, _ []string) error {
+func runHandler(cmd *cobra.Command, _ []string) error {
 	conf := config.Load()
 
-	// Validate inputs
+	// Validate inputs and configurations
 	{
 		if !conf.Network.IsSupported() {
 			return errors.Wrapf(errs.Unsupported, "%q network is not supported", conf.Network.String())
@@ -98,202 +86,78 @@ func runHandler(opts *runCmdOptions, cmd *cobra.Command, _ []string) error {
 	ctx, stop := signal.NotifyContext(cmd.Context(), os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
 	defer stop()
 
-	// Initialize worker context to separate worker's lifecycle from main process
-	ctxWorker, stopWorker := context.WithCancel(context.Background())
-	defer stopWorker()
+	injector := do.New(Modules)
+	do.ProvideValue(injector, conf)
+	do.ProvideValue(injector, ctx)
 
-	// Add logger context
-	ctxWorker = logger.WithContext(ctxWorker, slogx.Stringer("network", conf.Network))
+	// Initialize Bitcoin RPC client
+	do.Provide(injector, func(i do.Injector) (*rpcclient.Client, error) {
+		conf := do.MustInvoke[config.Config](i)
 
-	// Initialize Bitcoin Core RPC Client
-	client, err := rpcclient.New(&rpcclient.ConnConfig{
-		Host:         conf.BitcoinNode.Host,
-		User:         conf.BitcoinNode.User,
-		Pass:         conf.BitcoinNode.Pass,
-		DisableTLS:   conf.BitcoinNode.DisableTLS,
-		HTTPPostMode: true,
-	}, nil)
-	if err != nil {
-		logger.PanicContext(ctx, "Invalid Bitcoin node configuration", slogx.Error(err))
-	}
-	defer client.Shutdown()
-
-	// Check Bitcoin RPC connection
-	{
-		start := time.Now()
-		logger.InfoContext(ctx, "Connecting to Bitcoin Core RPC Server...", slogx.String("host", conf.BitcoinNode.Host))
-		if err := client.Ping(); err != nil {
-			logger.PanicContext(ctx, "Can't connect to Bitcoin Core RPC Server", slogx.String("host", conf.BitcoinNode.Host), slogx.Error(err))
+		client, err := rpcclient.New(&rpcclient.ConnConfig{
+			Host:         conf.BitcoinNode.Host,
+			User:         conf.BitcoinNode.User,
+			Pass:         conf.BitcoinNode.Pass,
+			DisableTLS:   conf.BitcoinNode.DisableTLS,
+			HTTPPostMode: true,
+		}, nil)
+		if err != nil {
+			return nil, errors.Wrap(err, "invalid Bitcoin node configuration")
 		}
-		logger.InfoContext(ctx, "Connected to Bitcoin Core RPC Server", slog.Duration("latency", time.Since(start)))
-	}
 
-	// TODO: create module command package.
-	// each module should have its own command package and main package will routing the command to the module command package.
+		// Check Bitcoin RPC connection
+		{
+			start := time.Now()
+			logger.InfoContext(ctx, "Connecting to Bitcoin Core RPC Server...", slogx.String("host", conf.BitcoinNode.Host))
+			if err := client.Ping(); err != nil {
+				return nil, errors.Wrapf(err, "can't connect to Bitcoin Core RPC Server %q", conf.BitcoinNode.Host)
+			}
+			logger.InfoContext(ctx, "Connected to Bitcoin Core RPC Server", slog.Duration("latency", time.Since(start)))
+		}
 
-	// TODO: refactor module name to specific type instead of string?
-	httpHandlers := make(map[string]HttpHandler, 0)
+		return client, nil
+	})
 
-	var reportingClient *reportingclient.ReportingClient
-	if !conf.Reporting.Disabled {
-		reportingClient, err = reportingclient.New(conf.Reporting)
+	// Initialize reporting client
+	do.Provide(injector, func(i do.Injector) (*reportingclient.ReportingClient, error) {
+		conf := do.MustInvoke[config.Config](i)
+		if conf.Reporting.Disabled {
+			return nil, nil
+		}
+
+		reportingClient, err := reportingclient.New(conf.Reporting)
 		if err != nil {
 			if errors.Is(err, errs.InvalidArgument) {
-				logger.PanicContext(ctx, "Invalid reporting configuration", slogx.Error(err))
+				return nil, errors.Wrap(err, "invalid reporting configuration")
 			}
-			logger.PanicContext(ctx, "Something went wrong, can't create reporting client", slogx.Error(err))
+			return nil, errors.Wrap(err, "can't create reporting client")
 		}
-	}
+		return reportingClient, nil
+	})
 
-	// Initialize Bitcoin Indexer
-	if opts.Bitcoin {
-		ctx := logger.WithContext(ctx, slogx.String("module", "bitcoin"))
-		var (
-			btcDB         btcdatagateway.BitcoinDataGateway
-			indexerInfoDB btcdatagateway.IndexerInformationDataGateway
-		)
-		switch strings.ToLower(conf.Modules.Bitcoin.Database) {
-		case "postgresql", "postgres", "pg":
-			pg, err := postgres.NewPool(ctx, conf.Modules.Bitcoin.Postgres)
-			if err != nil {
-				if errors.Is(err, errs.InvalidArgument) {
-					logger.PanicContext(ctx, "Invalid Postgres configuration for indexer", slogx.Error(err))
-				}
-				logger.PanicContext(ctx, "Something went wrong, can't create Postgres connection pool", slogx.Error(err))
-			}
-			defer pg.Close()
-			repo := btcpostgres.NewRepository(pg)
-			btcDB = repo
-			indexerInfoDB = repo
-		default:
-			return errors.Wrapf(errs.Unsupported, "%q database for indexer is not supported", conf.Modules.Bitcoin.Database)
-		}
-		if !opts.APIOnly {
-			processor := bitcoin.NewProcessor(conf, btcDB, indexerInfoDB)
-			datasource := datasources.NewBitcoinNode(client)
-			indexer := indexers.NewBitcoinIndexer(processor, datasource)
-			defer func() {
-				if err := indexer.ShutdownWithTimeout(shutdownTimeout); err != nil {
-					logger.ErrorContext(ctx, "Error during shutdown indexer", slogx.Error(err))
-					return
-				}
-				logger.InfoContext(ctx, "Indexer stopped gracefully")
-			}()
-
-			// Verify states before running Indexer
-			if err := processor.VerifyStates(ctx); err != nil {
-				return errors.WithStack(err)
-			}
-
-			// Run Indexer
-			go func() {
-				// stop main process if indexer stopped
-				defer stop()
-
-				logger.InfoContext(ctx, "Starting Gaze Indexer")
-				if err := indexer.Run(ctxWorker); err != nil {
-					logger.PanicContext(ctx, "Something went wrong, error during running indexer", slogx.Error(err))
-				}
-			}()
-		}
-	}
-
-	// Initialize Runes Indexer
-	if opts.Runes {
-		ctx := logger.WithContext(ctx, slogx.String("module", "runes"))
-		var (
-			runesDg       runesdatagateway.RunesDataGateway
-			indexerInfoDg runesdatagateway.IndexerInfoDataGateway
-		)
-		switch strings.ToLower(conf.Modules.Runes.Database) {
-		case "postgresql", "postgres", "pg":
-			pg, err := postgres.NewPool(ctx, conf.Modules.Runes.Postgres)
-			if err != nil {
-				if errors.Is(err, errs.InvalidArgument) {
-					logger.PanicContext(ctx, "Invalid Postgres configuration for indexer", slogx.Error(err))
-				}
-				logger.PanicContext(ctx, "Something went wrong, can't create Postgres connection pool", slogx.Error(err))
-			}
-			defer pg.Close()
-			runesRepo := runespostgres.NewRepository(pg)
-			runesDg = runesRepo
-			indexerInfoDg = runesRepo
-		default:
-			return errors.Wrapf(errs.Unsupported, "%q database for indexer is not supported", conf.Modules.Runes.Database)
-		}
-		var bitcoinDatasource indexers.BitcoinDatasource
-		var bitcoinClient btcclient.Contract
-		switch strings.ToLower(conf.Modules.Runes.Datasource) {
-		case "bitcoin-node":
-			bitcoinNodeDatasource := datasources.NewBitcoinNode(client)
-			bitcoinDatasource = bitcoinNodeDatasource
-			bitcoinClient = bitcoinNodeDatasource
-		case "database":
-			pg, err := postgres.NewPool(ctx, conf.Modules.Bitcoin.Postgres)
-			if err != nil {
-				if errors.Is(err, errs.InvalidArgument) {
-					logger.PanicContext(ctx, "Invalid Postgres configuration for datasource", slogx.Error(err))
-				}
-				logger.PanicContext(ctx, "Something went wrong, can't create Postgres connection pool", slogx.Error(err))
-			}
-			defer pg.Close()
-			btcRepo := btcpostgres.NewRepository(pg)
-			btcClientDB := btcclient.NewClientDatabase(btcRepo)
-			bitcoinDatasource = btcClientDB
-			bitcoinClient = btcClientDB
-		default:
-			return errors.Wrapf(errs.Unsupported, "%q datasource is not supported", conf.Modules.Runes.Datasource)
-		}
-
-		if !opts.APIOnly {
-			processor := runes.NewProcessor(runesDg, indexerInfoDg, bitcoinClient, bitcoinDatasource, conf.Network, reportingClient)
-			indexer := indexers.NewBitcoinIndexer(processor, bitcoinDatasource)
-			defer func() {
-				if err := indexer.ShutdownWithTimeout(shutdownTimeout); err != nil {
-					logger.ErrorContext(ctx, "Error during shutdown indexer", slogx.Error(err))
-					return
-				}
-				logger.InfoContext(ctx, "Indexer stopped gracefully")
-			}()
-
-			if err := processor.VerifyStates(ctx); err != nil {
-				return errors.WithStack(err)
-			}
-
-			// Run Indexer
-			go func() {
-				// stop main process if indexer stopped
-				defer stop()
-
-				logger.InfoContext(ctx, "Starting Gaze Indexer")
-				if err := indexer.Run(ctxWorker); err != nil {
-					logger.PanicContext(ctx, "Something went wrong, error during running indexer", slogx.Error(err))
-				}
-			}()
-		}
-
-		// Mount API
-		apiHandlers := lo.Uniq(conf.Modules.Runes.APIHandlers)
-		for _, handler := range apiHandlers {
-			switch handler { // TODO: support more handlers (e.g. gRPC)
-			case "http":
-				runesUsecase := runesusecase.New(runesDg, bitcoinClient)
-				runesHTTPHandler := runesapi.NewHTTPHandler(conf.Network, runesUsecase)
-				httpHandlers["runes"] = runesHTTPHandler
-			default:
-				logger.PanicContext(ctx, "Something went wrong, unsupported API handler", slogx.String("handler", handler))
-			}
-		}
-	}
-
-	// Wait for interrupt signal to gracefully stop the server with
-	// Setup HTTP server if there are any HTTP handlers
-	if len(httpHandlers) > 0 {
+	// Initialize HTTP server
+	do.Provide(injector, func(i do.Injector) (*fiber.App, error) {
 		app := fiber.New(fiber.Config{
-			AppName:      "Gaze Indexer",
-			ErrorHandler: errorhandler.NewHTTPErrorHandler(),
+			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",
+				}))
+			},
 		})
 		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{}) {
@@ -302,42 +166,69 @@ func runHandler(opts *runCmdOptions, 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,
 			}))
 
-		defer func() {
-			if err := app.ShutdownWithTimeout(shutdownTimeout); err != nil {
-				logger.ErrorContext(ctx, "Error during shutdown HTTP server", slogx.Error(err))
-				return
-			}
-			logger.InfoContext(ctx, "HTTP server stopped gracefully")
-		}()
-
 		// Health check
 		app.Get("/", func(c *fiber.Ctx) error {
 			return errors.WithStack(c.SendStatus(http.StatusOK))
 		})
 
-		// mount http handlers from each http-enabled module
-		for module, handler := range httpHandlers {
-			if err := handler.Mount(app); err != nil {
-				logger.PanicContext(ctx, "Something went wrong, can't mount HTTP handler", slogx.Error(err), slogx.String("module", module))
+		return app, nil
+	})
+
+	// Initialize worker context to separate worker's lifecycle from main process
+	ctxWorker, stopWorker := context.WithCancel(context.Background())
+	defer stopWorker()
+
+	// Add logger context
+	ctxWorker = logger.WithContext(ctxWorker, slogx.Stringer("network", conf.Network))
+
+	// Run modules
+	{
+		modules := lo.Uniq(conf.EnableModules)
+		modules = lo.Map(modules, func(item string, _ int) string { return strings.TrimSpace(item) })
+		modules = lo.Filter(modules, func(item string, _ int) bool { return item != "" })
+		for _, module := range modules {
+			ctx := logger.WithContext(ctxWorker, slogx.String("module", module))
+
+			indexer, err := do.InvokeNamed[indexer.IndexerWorker](injector, module)
+			if err != nil {
+				if errors.Is(err, do.ErrServiceNotFound) {
+					return errors.Errorf("Module %q is not supported", module)
+				}
+				return errors.Wrapf(err, "can't init module %q", module)
+			}
+
+			// Run Indexer
+			if !conf.APIOnly {
+				go func() {
+					// stop main process if indexer stopped
+					defer stop()
+
+					logger.InfoContext(ctx, "Starting Gaze Indexer")
+					if err := indexer.Run(ctx); err != nil {
+						logger.PanicContext(ctx, "Something went wrong, error during running indexer", slogx.Error(err))
+					}
+				}()
 			}
-			logger.InfoContext(ctx, "Mounted HTTP handler", slogx.String("module", module))
 		}
-
-		go func() {
-			// stop main process if API stopped
-			defer stop()
-
-			logger.InfoContext(ctx, "Started HTTP server", slog.Int("port", conf.HTTPServer.Port))
-			if err := app.Listen(fmt.Sprintf(":%d", conf.HTTPServer.Port)); err != nil {
-				logger.PanicContext(ctx, "Something went wrong, error during running HTTP server", slogx.Error(err))
-			}
-		}()
 	}
 
+	// Run API server
+	httpServer := do.MustInvoke[*fiber.App](injector)
+	go func() {
+		// stop main process if API stopped
+		defer stop()
+
+		logger.InfoContext(ctx, "Started HTTP server", slog.Int("port", conf.HTTPServer.Port))
+		if err := httpServer.Listen(fmt.Sprintf(":%d", conf.HTTPServer.Port)); err != nil {
+			logger.PanicContext(ctx, "Something went wrong, error during running HTTP server", slogx.Error(err))
+		}
+	}()
+
 	// Stop application if worker context is done
 	go func() {
 		<-ctxWorker.Done()
@@ -366,5 +257,9 @@ func runHandler(opts *runCmdOptions, cmd *cobra.Command, _ []string) error {
 		}
 	}()
 
+	if err := injector.Shutdown(); err != nil {
+		logger.PanicContext(ctx, "Failed while gracefully shutting down", slogx.Error(err))
+	}
+
 	return nil
 }

cmd/cmd_version.go

@@ -6,15 +6,15 @@ 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/bitcoin"
+	"github.com/gaze-network/indexer-network/modules/nodesale"
 	"github.com/gaze-network/indexer-network/modules/runes"
 	"github.com/spf13/cobra"
 )
 
 var versions = map[string]string{
-	"":        constants.Version,
-	"bitcoin": bitcoin.Version,
-	"runes":   runes.Version,
+	"":         constants.Version,
+	"runes":    runes.Version,
+	"nodesale": nodesale.Version,
 }
 
 type versionCmdOptions struct {
@@ -33,7 +33,7 @@ func NewVersionCommand() *cobra.Command {
 	}
 
 	flags := cmd.Flags()
-	flags.StringVar(&opts.Modules, "module", "", `Show version of a specific module. E.g. "bitcoin" | "runes"`)
+	flags.StringVar(&opts.Modules, "module", "", `Show version of a specific module. E.g. "runes"`)
 
 	return cmd
 }

cmd/migrate/cmd_down.go

@@ -17,7 +17,6 @@ import (
 
 type migrateDownCmdOptions struct {
 	DatabaseURL string
-	Bitcoin     bool
 	Runes       bool
 	All         bool
 }
@@ -60,7 +59,6 @@ func NewMigrateDownCommand() *cobra.Command {
 	}
 
 	flags := cmd.Flags()
-	flags.BoolVar(&opts.Bitcoin, "bitcoin", false, "Apply Bitcoin down migrations")
 	flags.BoolVar(&opts.Runes, "runes", false, "Apply Runes down migrations")
 	flags.StringVar(&opts.DatabaseURL, "database", "", "Database url to run migration on")
 	flags.BoolVar(&opts.All, "all", false, "Confirm apply ALL down migrations without prompt")
@@ -118,11 +116,6 @@ func migrateDownHandler(opts *migrateDownCmdOptions, _ *cobra.Command, args migr
 		return nil
 	}
 
-	if opts.Bitcoin {
-		if err := applyDownMigrations("Bitcoin", bitcoinMigrationSource, "bitcoin_schema_migrations"); err != nil {
-			return errors.WithStack(err)
-		}
-	}
 	if opts.Runes {
 		if err := applyDownMigrations("Runes", runesMigrationSource, "runes_schema_migrations"); err != nil {
 			return errors.WithStack(err)

cmd/migrate/cmd_up.go

@@ -16,7 +16,6 @@ import (
 
 type migrateUpCmdOptions struct {
 	DatabaseURL string
-	Bitcoin     bool
 	Runes       bool
 }
 
@@ -55,7 +54,6 @@ func NewMigrateUpCommand() *cobra.Command {
 	}
 
 	flags := cmd.Flags()
-	flags.BoolVar(&opts.Bitcoin, "bitcoin", false, "Apply Bitcoin up migrations")
 	flags.BoolVar(&opts.Runes, "runes", false, "Apply Runes up migrations")
 	flags.StringVar(&opts.DatabaseURL, "database", "", "Database url to run migration on")
 
@@ -103,11 +101,6 @@ func migrateUpHandler(opts *migrateUpCmdOptions, _ *cobra.Command, args migrateU
 		return nil
 	}
 
-	if opts.Bitcoin {
-		if err := applyUpMigrations("Bitcoin", bitcoinMigrationSource, "bitcoin_schema_migrations"); err != nil {
-			return errors.WithStack(err)
-		}
-	}
 	if opts.Runes {
 		if err := applyUpMigrations("Runes", runesMigrationSource, "runes_schema_migrations"); err != nil {
 			return errors.WithStack(err)

cmd/migrate/migrate.go

@@ -3,8 +3,7 @@ package migrate
 import "net/url"
 
 const (
-	bitcoinMigrationSource = "modules/bitcoin/database/postgresql/migrations"
-	runesMigrationSource   = "modules/runes/database/postgresql/migrations"
+	runesMigrationSource = "modules/runes/database/postgresql/migrations"
 )
 
 func cloneURLWithQuery(u *url.URL, newQuery url.Values) *url.URL {

config.example.yaml

@@ -23,24 +23,21 @@ 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:
-  # Configuration options for Bitcoin module. Can be removed if not used.
-  bitcoin:
-    database: "postgres" # Database to store bitcoin data. current supported databases: "postgres"
-    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.
-
   # Configuration options for Runes module. Can be removed if not used.
   runes:
     database: "postgres" # Database to store Runes data. current supported databases: "postgres"
-    datasource: "database" # Data source to be used for Bitcoin data. current supported data sources: "bitcoin-node" | "database". If "database" is used, it will use the database config in bitcoin module as datasource.
+    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:
@@ -50,3 +47,11 @@ 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.0.1"
+	Version = "v0.2.1"
 )

core/datasources/bitcoin_node.go

@@ -24,7 +24,7 @@ const (
 )
 
 // Make sure to implement the BitcoinDatasource interface
-var _ Datasource[[]*types.Block] = (*BitcoinNodeDatasource)(nil)
+var _ Datasource[*types.Block] = (*BitcoinNodeDatasource)(nil)
 
 // BitcoinNodeDatasource fetch data from Bitcoin node for Bitcoin Indexer
 type BitcoinNodeDatasource struct {
@@ -243,39 +243,32 @@ func (d *BitcoinNodeDatasource) prepareRange(fromHeight, toHeight int64) (start,
 }
 
 // GetTransaction fetch transaction from Bitcoin node
-func (d *BitcoinNodeDatasource) GetTransactionByHash(ctx context.Context, txHash chainhash.Hash) (*types.Transaction, error) {
+func (d *BitcoinNodeDatasource) GetRawTransactionAndHeightByTxHash(ctx context.Context, txHash chainhash.Hash) (*wire.MsgTx, int64, error) {
 	rawTxVerbose, err := d.btcclient.GetRawTransactionVerbose(&txHash)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to get raw transaction")
+		return nil, 0, errors.Wrap(err, "failed to get raw transaction")
 	}
 
 	blockHash, err := chainhash.NewHashFromStr(rawTxVerbose.BlockHash)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to parse block hash")
+		return nil, 0, errors.Wrap(err, "failed to parse block hash")
 	}
-	block, err := d.btcclient.GetBlockVerboseTx(blockHash)
+	block, err := d.btcclient.GetBlockVerbose(blockHash)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to get block header")
+		return nil, 0, errors.Wrap(err, "failed to get block header")
 	}
 
 	// parse tx
 	txBytes, err := hex.DecodeString(rawTxVerbose.Hex)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to decode transaction hex")
+		return nil, 0, errors.Wrap(err, "failed to decode transaction hex")
 	}
 	var msgTx wire.MsgTx
 	if err := msgTx.Deserialize(bytes.NewReader(txBytes)); err != nil {
-		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 nil, 0, errors.Wrap(err, "failed to deserialize transaction")
 	}
 
-	return types.ParseMsgTx(&msgTx, block.Height, *blockHash, txIndex), nil
+	return &msgTx, block.Height, nil
 }
 
 // GetBlockHeader fetch block header from Bitcoin node

core/datasources/datasources.go

@@ -10,7 +10,7 @@ import (
 // Datasource is an interface for indexer data sources.
 type Datasource[T any] interface {
 	Name() string
-	Fetch(ctx context.Context, from, to int64) (T, error)
-	FetchAsync(ctx context.Context, from, to int64, ch chan<- T) (*subscription.ClientSubscription[T], error)
+	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)
 }

core/indexer/indexer.go

@@ -1,4 +1,4 @@
-package indexers
+package indexer
 
 import (
 	"context"
@@ -16,20 +16,15 @@ import (
 
 const (
 	maxReorgLookBack = 1000
+
+	// pollingInterval is the default polling interval for the indexer polling worker
+	pollingInterval = 15 * time.Second
 )
 
-type (
-	BitcoinProcessor  Processor[[]*types.Block]
-	BitcoinDatasource datasources.Datasource[[]*types.Block]
-)
-
-// Make sure to implement the IndexerWorker interface
-var _ IndexerWorker = (*BitcoinIndexer)(nil)
-
-// BitcoinIndexer is the polling indexer for sync Bitcoin data to the database.
-type BitcoinIndexer struct {
-	Processor    BitcoinProcessor
-	Datasource   BitcoinDatasource
+// Indexer generic indexer for fetching and processing data
+type Indexer[T Input] struct {
+	Processor    Processor[T]
+	Datasource   datasources.Datasource[T]
 	currentBlock types.BlockHeader
 
 	quitOnce sync.Once
@@ -37,9 +32,9 @@ type BitcoinIndexer struct {
 	done     chan struct{}
 }
 
-// NewBitcoinIndexer create new BitcoinIndexer
-func NewBitcoinIndexer(processor BitcoinProcessor, datasource BitcoinDatasource) *BitcoinIndexer {
-	return &BitcoinIndexer{
+// New create new generic indexer
+func New[T Input](processor Processor[T], datasource datasources.Datasource[T]) *Indexer[T] {
+	return &Indexer[T]{
 		Processor:  processor,
 		Datasource: datasource,
 
@@ -48,21 +43,17 @@ func NewBitcoinIndexer(processor BitcoinProcessor, datasource BitcoinDatasource)
 	}
 }
 
-func (*BitcoinIndexer) Type() string {
-	return "bitcoin"
-}
-
-func (i *BitcoinIndexer) Shutdown() error {
+func (i *Indexer[T]) Shutdown() error {
 	return i.ShutdownWithContext(context.Background())
 }
 
-func (i *BitcoinIndexer) ShutdownWithTimeout(timeout time.Duration) error {
+func (i *Indexer[T]) ShutdownWithTimeout(timeout time.Duration) error {
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()
 	return i.ShutdownWithContext(ctx)
 }
 
-func (i *BitcoinIndexer) ShutdownWithContext(ctx context.Context) (err error) {
+func (i *Indexer[T]) ShutdownWithContext(ctx context.Context) (err error) {
 	i.quitOnce.Do(func() {
 		close(i.quit)
 		select {
@@ -76,12 +67,11 @@ func (i *BitcoinIndexer) ShutdownWithContext(ctx context.Context) (err error) {
 	return
 }
 
-func (i *BitcoinIndexer) Run(ctx context.Context) (err error) {
+func (i *Indexer[T]) Run(ctx context.Context) (err error) {
 	defer close(i.done)
 
 	ctx = logger.WithContext(ctx,
 		slog.String("package", "indexers"),
-		slog.String("indexer", i.Type()),
 		slog.String("processor", i.Processor.Name()),
 		slog.String("datasource", i.Datasource.Name()),
 	)
@@ -101,6 +91,10 @@ func (i *BitcoinIndexer) 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
@@ -114,15 +108,15 @@ func (i *BitcoinIndexer) Run(ctx context.Context) (err error) {
 	}
 }
 
-func (i *BitcoinIndexer) process(ctx context.Context) (err error) {
+func (i *Indexer[T]) process(ctx context.Context) (err error) {
 	// height range to fetch data
 	from, to := i.currentBlock.Height+1, int64(-1)
 
-	logger.InfoContext(ctx, "Start fetching bitcoin blocks", slog.Int64("from", from))
-	ch := make(chan []*types.Block)
+	logger.InfoContext(ctx, "Start fetching input data", slog.Int64("from", from))
+	ch := make(chan []T)
 	subscription, err := i.Datasource.FetchAsync(ctx, from, to, ch)
 	if err != nil {
-		return errors.Wrap(err, "failed to fetch data")
+		return errors.Wrap(err, "failed to fetch input data")
 	}
 	defer subscription.Unsubscribe()
 
@@ -130,21 +124,24 @@ func (i *BitcoinIndexer) process(ctx context.Context) (err error) {
 		select {
 		case <-i.quit:
 			return nil
-		case blocks := <-ch:
-			// empty blocks
-			if len(blocks) == 0 {
+		case inputs := <-ch:
+			// empty inputs
+			if len(inputs) == 0 {
 				continue
 			}
 
+			firstInput := inputs[0]
+			firstInputHeader := firstInput.BlockHeader()
+
 			startAt := time.Now()
 			ctx := logger.WithContext(ctx,
-				slogx.Int64("from", blocks[0].Header.Height),
-				slogx.Int64("to", blocks[len(blocks)-1].Header.Height),
+				slogx.Int64("from", firstInputHeader.Height),
+				slogx.Int64("to", inputs[len(inputs)-1].BlockHeader().Height),
 			)
 
-			// validate reorg from first block
+			// validate reorg from first input
 			{
-				remoteBlockHeader := blocks[0].Header
+				remoteBlockHeader := firstInputHeader
 				if !remoteBlockHeader.PrevBlock.IsEqual(&i.currentBlock.Hash) {
 					logger.WarnContext(ctx, "Detected chain reorganization. Searching for fork point...",
 						slogx.String("event", "reorg_detected"),
@@ -210,33 +207,36 @@ func (i *BitcoinIndexer) process(ctx context.Context) (err error) {
 				}
 			}
 
-			// validate is block is continuous and no reorg
-			for i := 1; i < len(blocks); i++ {
-				if blocks[i].Header.Height != blocks[i-1].Header.Height+1 {
-					return errors.Wrapf(errs.InternalError, "block is not continuous, block[%d] height: %d, block[%d] height: %d", i-1, blocks[i-1].Header.Height, i, blocks[i].Header.Height)
+			// validate is input is continuous and no reorg
+			prevHeader := i.currentBlock
+			for i, input := range inputs {
+				header := input.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 !blocks[i].Header.PrevBlock.IsEqual(&blocks[i-1].Header.Hash) {
-					logger.WarnContext(ctx, "Chain Reorganization occurred in the middle of batch fetching blocks, need to try to fetch again")
+				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_blocks", len(blocks)))
+			ctx = logger.WithContext(ctx, slog.Int("total_inputs", len(inputs)))
 
-			// Start processing blocks
-			logger.InfoContext(ctx, "Processing blocks")
-			if err := i.Processor.Process(ctx, blocks); err != nil {
+			// Start processing input
+			logger.InfoContext(ctx, "Processing inputs")
+			if err := i.Processor.Process(ctx, inputs); err != nil {
 				return errors.WithStack(err)
 			}
 
 			// Update current state
-			i.currentBlock = blocks[len(blocks)-1].Header
+			i.currentBlock = inputs[len(inputs)-1].BlockHeader()
 
-			logger.InfoContext(ctx, "Processed blocks successfully",
-				slogx.String("event", "processed_blocks"),
+			logger.InfoContext(ctx, "Processed inputs successfully",
+				slogx.String("event", "processed_inputs"),
 				slogx.Int64("current_block", i.currentBlock.Height),
 				slogx.Duration("duration", time.Since(startAt)),
 			)

core/indexer/interface.go

@@ -1,4 +1,4 @@
-package indexers
+package indexer
 
 import (
 	"context"
@@ -7,24 +7,15 @@ import (
 	"github.com/gaze-network/indexer-network/core/types"
 )
 
-const (
-	// pollingInterval is the default polling interval for the indexer polling worker
-	pollingInterval = 15 * time.Second
-)
-
-type IndexerWorker interface {
-	Type() string
-	Run(ctx context.Context) error
-	Shutdown() error
-	ShutdownWithTimeout(timeout time.Duration) error
-	ShutdownWithContext(ctx context.Context) error
+type Input interface {
+	BlockHeader() types.BlockHeader
 }
 
-type Processor[T any] interface {
+type Processor[T Input] interface {
 	Name() string
 
 	// Process processes the input data and indexes it.
-	Process(ctx context.Context, inputs T) error
+	Process(ctx context.Context, inputs []T) error
 
 	// CurrentBlock returns the latest indexed block header.
 	CurrentBlock(ctx context.Context) (types.BlockHeader, error)
@@ -38,4 +29,14 @@ type Processor[T any] 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 {
+	Shutdown() error
+	ShutdownWithTimeout(timeout time.Duration) error
+	ShutdownWithContext(ctx context.Context) (err error)
+	Run(ctx context.Context) (err error)
 }

core/types/bitcoin_block.go

@@ -38,6 +38,10 @@ type Block struct {
 	Transactions []*Transaction
 }
 
+func (b *Block) BlockHeader() BlockHeader {
+	return b.Header
+}
+
 func ParseMsgBlock(src *wire.MsgBlock, height int64) *Block {
 	hash := src.Header.BlockHash()
 	return &Block{

go.mod

@@ -6,37 +6,42 @@ require (
 	github.com/Cleverse/go-utilities/utils v0.0.0-20240119201306-d71eb577ef11
 	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
 	github.com/gofiber/fiber/v2 v2.52.4
 	github.com/golang-migrate/migrate/v4 v4.17.1
-	github.com/jackc/pgx v3.6.2+incompatible
 	github.com/jackc/pgx/v5 v5.5.5
 	github.com/mcosta74/pgx-slog v0.3.0
 	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/spf13/cobra v1.8.0
 	github.com/spf13/pflag v1.0.5
 	github.com/spf13/viper v1.18.2
-	github.com/stretchr/testify v1.8.4
+	github.com/stretchr/testify v1.9.0
 	github.com/valyala/fasthttp v1.51.0
 	go.uber.org/automaxprocs v1.5.3
-	golang.org/x/sync v0.5.0
+	golang.org/x/sync v0.7.0
+	google.golang.org/protobuf v1.33.0
 )
 
+require github.com/stretchr/objx v0.5.2 // indirect
+
 require (
 	github.com/andybalholm/brotli v1.0.5 // indirect
-	github.com/btcsuite/btcd/btcec/v2 v2.1.3 // indirect
+	github.com/bitonicnl/verify-signed-message v0.7.1
+	github.com/btcsuite/btcd/btcec/v2 v2.3.3
 	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.0 // indirect
-	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 // indirect
+	github.com/decred/dcrd/crypto/blake256 v1.0.1 // indirect
+	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0
 	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
@@ -47,6 +52,7 @@ require (
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/jackc/pgpassfile v1.0.0 // indirect
 	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/klauspost/compress v1.17.0 // indirect
 	github.com/kr/pretty v0.3.1 // indirect
@@ -64,6 +70,7 @@ require (
 	github.com/rogpeppe/go-internal v1.9.0 // indirect
 	github.com/sagikazarmark/locafero v0.4.0 // indirect
 	github.com/sagikazarmark/slog-shim v0.1.0 // indirect
+	github.com/samber/go-type-to-string v1.4.0 // indirect
 	github.com/sourcegraph/conc v0.3.0 // indirect
 	github.com/spf13/afero v1.11.0 // indirect
 	github.com/spf13/cast v1.6.0 // indirect
@@ -72,10 +79,10 @@ 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.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/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
 	gopkg.in/ini.v1 v1.67.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -7,18 +7,23 @@ github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5
 github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII=
 github.com/andybalholm/brotli v1.0.5 h1:8uQZIdzKmjc/iuPu7O2ioW48L81FgatrcpfFmiq/cCs=
 github.com/andybalholm/brotli v1.0.5/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig=
+github.com/bitonicnl/verify-signed-message v0.7.1 h1:1Qku9k9WgzobjqBY7tT3CLjWxtTJZxkYNhOV6QeCTjY=
+github.com/bitonicnl/verify-signed-message v0.7.1/go.mod h1:PR60twfJIaHEo9Wb6eJBh8nBHEZIQQx8CvRwh0YmEPk=
 github.com/btcsuite/btcd v0.20.1-beta/go.mod h1:wVuoA8VJLEcwgqHBwHmzLRazpKxTv13Px/pDuV7OomQ=
 github.com/btcsuite/btcd v0.22.0-beta.0.20220111032746-97732e52810c/go.mod h1:tjmYdS6MLJ5/s0Fj4DbLgSbDHbEqLJrtnHecBFkdz5M=
 github.com/btcsuite/btcd v0.23.5-0.20231215221805-96c9fd8078fd/go.mod h1:nm3Bko6zh6bWP60UxwoT5LzdGJsQJaPo6HjduXq9p6A=
 github.com/btcsuite/btcd v0.24.0 h1:gL3uHE/IaFj6fcZSu03SvqPMSx7s/dPzfpG/atRwWdo=
 github.com/btcsuite/btcd v0.24.0/go.mod h1:K4IDc1593s8jKXIF7yS7yCTSxrknB9z0STzc2j6XgE4=
 github.com/btcsuite/btcd/btcec/v2 v2.1.0/go.mod h1:2VzYrv4Gm4apmbVVsSq5bqf1Ec8v56E48Vt0Y/umPgA=
-github.com/btcsuite/btcd/btcec/v2 v2.1.3 h1:xM/n3yIhHAhHy04z4i43C8p4ehixJZMsnrVJkgl+MTE=
 github.com/btcsuite/btcd/btcec/v2 v2.1.3/go.mod h1:ctjw4H1kknNJmRN4iP1R7bTQ+v3GJkZBd6mui8ZsAZE=
+github.com/btcsuite/btcd/btcec/v2 v2.3.3 h1:6+iXlDKE8RMtKsvK0gshlXIuPbyWM/h84Ensb7o3sC0=
+github.com/btcsuite/btcd/btcec/v2 v2.3.3/go.mod h1:zYzJ8etWJQIv1Ogk7OzpWjowwOdXY1W/17j2MW85J04=
 github.com/btcsuite/btcd/btcutil v1.0.0/go.mod h1:Uoxwv0pqYWhD//tfTiipkxNfdhG9UrLwaeswfjfdF0A=
 github.com/btcsuite/btcd/btcutil v1.1.0/go.mod h1:5OapHB7A2hBBWLm48mmw4MOHNJCcUBTwmWH/0Jn8VHE=
 github.com/btcsuite/btcd/btcutil v1.1.5 h1:+wER79R5670vs/ZusMTF1yTcRYE5GUsFbdjdisflzM8=
 github.com/btcsuite/btcd/btcutil v1.1.5/go.mod h1:PSZZ4UitpLBWzxGd5VGOrLnmOjtPP/a6HaFo12zMs00=
+github.com/btcsuite/btcd/btcutil/psbt v1.1.9 h1:UmfOIiWMZcVMOLaN+lxbbLSuoINGS1WmK1TZNI0b4yk=
+github.com/btcsuite/btcd/btcutil/psbt v1.1.9/go.mod h1:ehBEvU91lxSlXtA+zZz3iFYx7Yq9eqnKx4/kSrnsvMY=
 github.com/btcsuite/btcd/chaincfg/chainhash v1.0.0/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc=
 github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc=
 github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0 h1:59Kx4K6lzOW5w6nFlA0v5+lk/6sjybR934QNHSJZPTQ=
@@ -50,10 +55,12 @@ github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/decred/dcrd/crypto/blake256 v1.0.0 h1:/8DMNYp9SGi5f0w7uCm6d6M4OU2rGFK09Y2A4Xv7EE0=
 github.com/decred/dcrd/crypto/blake256 v1.0.0/go.mod h1:sQl2p6Y26YV+ZOcSTP6thNdn47hh8kt6rqSlvmrXFAc=
-github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 h1:YLtO71vCjJRCBcrPMtQ9nqBsqpA1m5sE92cU+pd5Mcc=
+github.com/decred/dcrd/crypto/blake256 v1.0.1 h1:7PltbUIQB7u/FfZ39+DGa/ShuMyJ5ilcvdfma9wOH6Y=
+github.com/decred/dcrd/crypto/blake256 v1.0.1/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo=
 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1/go.mod h1:hyedUtir6IdtD/7lIxGeCxkaw7y45JueMRL4DIyJDKs=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0 h1:rpfIENRNNilwHwZeG5+P150SMrnNEcHYvcCuK6dPZSg=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0/go.mod h1:v57UDF4pDQJcEfFUCRop3lJL149eHGSe9Jvczhzjo/0=
 github.com/decred/dcrd/lru v1.0.0/go.mod h1:mxKOwFd7lFjN2GZYsiz/ecgqR6kkYAl+0pz0tEMk218=
 github.com/dhui/dktest v0.4.1 h1:/w+IWuDXVymg3IrRJCHHOkMK10m9aNVMOyD0X12YVTg=
 github.com/dhui/dktest v0.4.1/go.mod h1:DdOqcUpL7vgyP4GlF3X3w7HbSlz8cEQzwewPveYEQbA=
@@ -96,8 +103,8 @@ github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEW
 github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
-github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/uuid v1.5.0 h1:1p67kYwdtXjb0gL0BPiP1Av9wiZPo5A8z2cWkTZ+eyU=
 github.com/google/uuid v1.5.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
@@ -191,6 +198,10 @@ github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6ke
 github.com/sagikazarmark/locafero v0.4.0/go.mod h1:Pe1W6UlPYUk/+wc/6KFhbORCfqzgYEpgQ3O5fPuL3H4=
 github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6gto+ugjYE=
 github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ=
+github.com/samber/do/v2 v2.0.0-beta.7 h1:tmdLOVSCbTA6uGWLU5poi/nZvMRh5QxXFJ9vHytU+Jk=
+github.com/samber/do/v2 v2.0.0-beta.7/go.mod h1:+LpV3vu4L81Q1JMZNSkMvSkW9lt4e5eJoXoZHkeBS4c=
+github.com/samber/go-type-to-string v1.4.0 h1:KXphToZgiFdnJQxryU25brhlh/CqY/cwJVeX2rfmow0=
+github.com/samber/go-type-to-string v1.4.0/go.mod h1:jpU77vIDoIxkahknKDoEx9C8bQ1ADnh2sotZ8I4QqBU=
 github.com/samber/lo v1.39.0 h1:4gTz1wUhNYLhFSKl6O+8peW0v2F4BCY034GRpU9WnuA=
 github.com/samber/lo v1.39.0/go.mod h1:+m/ZKRl6ClXCE2Lgf3MsQlWfh4bn1bz6CXEOxnEXnEA=
 github.com/shopspring/decimal v1.3.1 h1:2Usl1nmF/WZucqkFZhnfFYxxxu8LG21F6nPQBE5gKV8=
@@ -210,12 +221,15 @@ github.com/spf13/viper v1.18.2/go.mod h1:EKmWIqdnk5lOcmR72yw6hS+8OPYcwD0jteitLMV
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
+github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
 github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc=
@@ -231,20 +245,22 @@ go.uber.org/atomic v1.9.0 h1:ECmE8Bn/WFTYwEW/bpKD3M8VtR/zQVbavAoalC1PYyE=
 go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
 go.uber.org/automaxprocs v1.5.3 h1:kWazyxZUrS3Gs4qUpbwo5kEIMGe/DAvi5Z4tl2NW4j8=
 go.uber.org/automaxprocs v1.5.3/go.mod h1:eRbA25aqJrxAbsLO0xy5jVwPt7FQnRgjW+efnwa1WM0=
+go.uber.org/goleak v1.2.1 h1:NBol2c7O1ZokfZ0LEU9K6Whx/KnwvepVetCUhtKja4A=
+go.uber.org/goleak v1.2.1/go.mod h1:qlT2yGI9QafXHhZZLxlSuNsMw3FFLxBr+tBRlmO1xH4=
 go.uber.org/multierr v1.9.0 h1:7fIwc/ZtS0q++VgcfqFDxSBZVv/Xo49/SYnDFupUwlI=
 go.uber.org/multierr v1.9.0/go.mod h1:X2jQV1h+kxSjClGpnseKVIxpmcjrj7MNnI0bnlfKTVQ=
 golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.20.0 h1:jmAMJJZXr5KiCw05dfYK9QnqaqKLYXijU23lsEdcQqg=
-golang.org/x/crypto v0.20.0/go.mod h1:Xwo95rrVNIoSMx9wa1JroENMToLWn3RNVrTBpLHgZPQ=
-golang.org/x/exp v0.0.0-20230905200255-921286631fa9 h1:GoHiUyI/Tp2nVkLI2mCxVkOjsbSXD66ic0XW0js0R9g=
-golang.org/x/exp v0.0.0-20230905200255-921286631fa9/go.mod h1:S2oDrQGGwySpoQPVqRShND87VCbxmc6bL1Yd2oYrm6k=
+golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI=
+golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
+golang.org/x/exp v0.0.0-20240525044651-4c93da0ed11d h1:N0hmiNbwsSNwHBAvR3QB5w25pUwH4tK0Y/RltD1j1h4=
+golang.org/x/exp v0.0.0-20240525044651-4c93da0ed11d/go.mod h1:XtvwrStGgqGPLc4cjQfWqZHG1YFdYs6swckp8vpsjnc=
 golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.12.0 h1:rmsUpXtvNzj340zd98LZ4KntptpfRHwpFOHG188oHXc=
-golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/mod v0.17.0 h1:zY54UmvipHiNd+pm+m0x9KhZ9hl1/7QNMyxXbc6ICqA=
+golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/net v0.0.0-20180719180050-a680a1efc54d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
@@ -259,8 +275,8 @@ golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.5.0 h1:60k92dhOjHxJkrqnwsfl8KuaHbn/5dl0lUPUklKo3qE=
-golang.org/x/sync v0.5.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
+golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -273,19 +289,19 @@ golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.17.0 h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y=
-golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
+golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
-golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk=
+golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
 golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.13.0 h1:Iey4qkscZuv0VvIt8E0neZjtPVQFSc870HQ448QgEmQ=
-golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58=
+golang.org/x/tools v0.21.0 h1:qc0xYgIbsSDt9EyWz05J5wfa7LOVW0YTLOXrqdLAWIw=
+golang.org/x/tools v0.21.0/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
@@ -296,6 +312,8 @@ google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQ
 google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
 google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
 google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
+google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=

internal/config/config.go

@@ -8,10 +8,12 @@ import (
 
 	"github.com/cockroachdb/errors"
 	"github.com/gaze-network/indexer-network/common"
-	btcconfig "github.com/gaze-network/indexer-network/modules/bitcoin/config"
+	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"
@@ -25,20 +27,31 @@ var (
 			Output: "TEXT",
 		},
 		Network: common.NetworkMainnet,
+		HTTPServer: HTTPServerConfig{
+			Port: 8080,
+		},
 		BitcoinNode: BitcoinNodeClient{
 			User: "user",
 			Pass: "pass",
 		},
+		Modules: Modules{
+			Runes: runesconfig.Config{
+				Datasource: "bitcoin-node",
+				Database:   "postgres",
+			},
+		},
 	}
 )
 
 type Config struct {
-	Logger      logger.Config          `mapstructure:"logger"`
-	BitcoinNode BitcoinNodeClient      `mapstructure:"bitcoin_node"`
-	Network     common.Network         `mapstructure:"network"`
-	HTTPServer  HTTPServerConfig       `mapstructure:"http_server"`
-	Modules     Modules                `mapstructure:"modules"`
-	Reporting   reportingclient.Config `mapstructure:"reporting"`
+	EnableModules []string               `mapstructure:"enable_modules"`
+	APIOnly       bool                   `mapstructure:"api_only"`
+	Logger        logger.Config          `mapstructure:"logger"`
+	BitcoinNode   BitcoinNodeClient      `mapstructure:"bitcoin_node"`
+	Network       common.Network         `mapstructure:"network"`
+	HTTPServer    HTTPServerConfig       `mapstructure:"http_server"`
+	Modules       Modules                `mapstructure:"modules"`
+	Reporting     reportingclient.Config `mapstructure:"reporting"`
 }
 
 type BitcoinNodeClient struct {
@@ -49,12 +62,14 @@ type BitcoinNodeClient struct {
 }
 
 type Modules struct {
-	Bitcoin btcconfig.Config   `mapstructure:"bitcoin"`
-	Runes   runesconfig.Config `mapstructure:"runes"`
+	Runes    runesconfig.Config    `mapstructure:"runes"`
+	NodeSale nodesaleconfig.Config `mapstructure:"nodesale"`
 }
 
 type HTTPServerConfig struct {
-	Port int `mapstructure:"port"`
+	Port      int                               `mapstructure:"port"`
+	Logger    requestlogger.Config              `mapstructure:"logger"`
+	RequestIP requestcontext.WithClientIPConfig `mapstructure:"requestip"`
 }
 
 // Parse parse the configuration from environment variables

main.go

@@ -7,7 +7,6 @@ import (
 	"syscall"
 
 	"github.com/gaze-network/indexer-network/cmd"
-	_ "go.uber.org/automaxprocs"
 )
 
 func main() {

modules/bitcoin/btcclient/client_db.go

@@ -1,244 +0,0 @@
-package btcclient
-
-import (
-	"context"
-	"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"
-	"github.com/gaze-network/indexer-network/core/types"
-	"github.com/gaze-network/indexer-network/internal/subscription"
-	"github.com/gaze-network/indexer-network/modules/bitcoin/datagateway"
-	"github.com/gaze-network/indexer-network/pkg/logger"
-	"github.com/gaze-network/indexer-network/pkg/logger/slogx"
-	cstream "github.com/planxnx/concurrent-stream"
-	"github.com/samber/lo"
-)
-
-// TODO: Refactor this, datasources.BitcoinNode and This package is the same.
-
-const (
-	blockStreamChunkSize = 100
-)
-
-// Make sure to implement the BitcoinDatasource interface
-var _ datasources.Datasource[[]*types.Block] = (*ClientDatabase)(nil)
-
-// ClientDatabase is a client to connect to the bitcoin database.
-type ClientDatabase struct {
-	bitcoinDg datagateway.BitcoinDataGateway
-}
-
-func NewClientDatabase(bitcoinDg datagateway.BitcoinDataGateway) *ClientDatabase {
-	return &ClientDatabase{
-		bitcoinDg: bitcoinDg,
-	}
-}
-
-func (d ClientDatabase) Name() string {
-	return "bitcoin_database"
-}
-
-func (d *ClientDatabase) 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 *ClientDatabase) 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()),
-	)
-
-	from, to, 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
-	}
-
-	// Create parallel stream
-	out := make(chan []*types.Block)
-	stream := cstream.NewStream(ctx, 8, out)
-
-	// create slice of block height to fetch
-	blockHeights := make([]int64, 0, to-from+1)
-	for i := from; i <= to; i++ {
-		blockHeights = append(blockHeights, i)
-	}
-
-	// Wait for stream to finish and close out channel
-	go func() {
-		defer close(out)
-		_ = stream.Wait()
-	}()
-
-	// Fan-out blocks to subscription channel
-	go func() {
-		defer func() {
-			// add a bit delay to prevent shutdown before client receive all blocks
-			time.Sleep(100 * time.Millisecond)
-
-			subscription.Unsubscribe()
-		}()
-		for {
-			select {
-			case data, ok := <-out:
-				// stream closed
-				if !ok {
-					return
-				}
-
-				// empty blocks
-				if len(data) == 0 {
-					continue
-				}
-
-				// send blocks to subscription channel
-				if err := subscription.Send(ctx, data); err != nil {
-					if errors.Is(err, errs.Closed) {
-						return
-					}
-					logger.WarnContext(ctx, "Failed to send bitcoin blocks to subscription client",
-						slogx.Int64("start", data[0].Header.Height),
-						slogx.Int64("end", data[len(data)-1].Header.Height),
-						slogx.Error(err),
-					)
-				}
-			case <-ctx.Done():
-				return
-			}
-		}
-	}()
-
-	// Parallel fetch blocks from Bitcoin node until complete all block heights
-	// or subscription is done.
-	go func() {
-		defer stream.Close()
-		done := subscription.Done()
-		chunks := lo.Chunk(blockHeights, blockStreamChunkSize)
-		for _, chunk := range chunks {
-			chunk := chunk
-			select {
-			case <-done:
-				return
-			case <-ctx.Done():
-				return
-			default:
-				if len(chunk) == 0 {
-					continue
-				}
-				stream.Go(func() []*types.Block {
-					startAt := time.Now()
-					defer func() {
-						logger.DebugContext(ctx, "Fetched chunk of blocks from Bitcoin node",
-							slogx.Int("total_blocks", len(chunk)),
-							slogx.Int64("from", chunk[0]),
-							slogx.Int64("to", chunk[len(chunk)-1]),
-							slogx.Duration("duration", time.Since(startAt)),
-						)
-					}()
-
-					fromHeight, toHeight := chunk[0], chunk[len(chunk)-1]
-					blocks, err := d.bitcoinDg.GetBlocksByHeightRange(ctx, fromHeight, toHeight)
-					if err != nil {
-						logger.ErrorContext(ctx, "Can't get block data from Bitcoin database",
-							slogx.Error(err),
-							slogx.Int64("from", fromHeight),
-							slogx.Int64("to", toHeight),
-						)
-						if err := subscription.SendError(ctx, errors.Wrapf(err, "failed to get blocks: from_height: %d, to_height: %d", fromHeight, toHeight)); err != nil {
-							logger.WarnContext(ctx, "Failed to send datasource error to subscription client", slogx.Error(err))
-						}
-						return nil
-					}
-					return blocks
-				})
-			}
-		}
-	}()
-
-	return subscription.Client(), nil
-}
-
-func (c *ClientDatabase) GetBlockHeader(ctx context.Context, height int64) (types.BlockHeader, error) {
-	header, err := c.bitcoinDg.GetBlockHeaderByHeight(ctx, height)
-	if err != nil {
-		return types.BlockHeader{}, errors.WithStack(err)
-	}
-	return header, nil
-}
-
-func (c *ClientDatabase) prepareRange(ctx context.Context, fromHeight, toHeight int64) (start, end int64, skip bool, err error) {
-	start = fromHeight
-	end = toHeight
-
-	// get current bitcoin block height
-	latestBlock, err := c.bitcoinDg.GetLatestBlockHeader(ctx)
-	if err != nil {
-		return -1, -1, 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 > latestBlock.Height {
-		end = latestBlock.Height
-	}
-
-	// if start is greater than end, skip this round
-	if start > end {
-		return -1, -1, true, nil
-	}
-
-	return start, end, false, nil
-}
-
-// GetTransactionByHash returns a transaction with the given hash. Returns errs.NotFound if transaction does not exist.
-func (c *ClientDatabase) GetTransactionByHash(ctx context.Context, txHash chainhash.Hash) (*types.Transaction, error) {
-	tx, err := c.bitcoinDg.GetTransactionByHash(ctx, txHash)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to get transaction by hash")
-	}
-	return tx, nil
-}

modules/bitcoin/btcclient/contract.go

@@ -1,12 +0,0 @@
-package btcclient
-
-import (
-	"context"
-
-	"github.com/btcsuite/btcd/chaincfg/chainhash"
-	"github.com/gaze-network/indexer-network/core/types"
-)
-
-type Contract interface {
-	GetTransactionByHash(ctx context.Context, txHash chainhash.Hash) (*types.Transaction, error)
-}

modules/bitcoin/config/config.go

@@ -1,8 +0,0 @@
-package config
-
-import "github.com/gaze-network/indexer-network/internal/postgres"
-
-type Config struct {
-	Database string          `mapstructure:"database"` // Database to store bitcoin data.
-	Postgres postgres.Config `mapstructure:"postgres"`
-}

modules/bitcoin/constants.go

@@ -1,26 +0,0 @@
-package bitcoin
-
-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
-)
-
-var (
-	// defaultCurrentBlockHeight is the default value for the current block height for first time indexing
-	defaultCurrentBlock = types.BlockHeader{
-		Hash:   common.ZeroHash,
-		Height: -1,
-	}
-
-	lastV1Block = types.BlockHeader{
-		Hash:   *utils.Must(chainhash.NewHashFromStr("00000000000001aa077d7aa84c532a4d69bdbff519609d1da0835261b7a74eb6")),
-		Height: 227835,
-	}
-)

modules/bitcoin/database/postgresql/migrations/000001_initialize_table.down.sql

@@ -1,18 +0,0 @@
-BEGIN;
-
--- DROP INDEX
-DROP INDEX IF EXISTS bitcoin_blocks_block_hash_idx;
-DROP INDEX IF EXISTS bitcoin_transactions_tx_hash_idx;
-DROP INDEX IF EXISTS bitcoin_transactions_block_hash_idx;
-DROP INDEX IF EXISTS bitcoin_transaction_txouts_pkscript_idx;
-DROP INDEX IF EXISTS bitcoin_transaction_txins_prevout_idx;
-
--- DROP TABLE
-DROP TABLE IF EXISTS "bitcoin_indexer_stats";
-DROP TABLE IF EXISTS "bitcoin_indexer_db_version";
-DROP TABLE IF EXISTS "bitcoin_transaction_txins";
-DROP TABLE IF EXISTS "bitcoin_transaction_txouts";
-DROP TABLE IF EXISTS "bitcoin_transactions";
-DROP TABLE IF EXISTS "bitcoin_blocks";
-
-COMMIT;

modules/bitcoin/database/postgresql/migrations/000001_initialize_table.up.sql

@@ -1,72 +0,0 @@
-BEGIN;
-
--- Indexer Client Information
-
-CREATE TABLE IF NOT EXISTS "bitcoin_indexer_stats" (
-	"id" BIGSERIAL PRIMARY KEY,
-	"client_version" TEXT NOT NULL,
-	"network" TEXT NOT NULL,
-	"created_at" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP
-);
-
-CREATE TABLE IF NOT EXISTS "bitcoin_indexer_db_version" (
-	"id" BIGSERIAL PRIMARY KEY,
-	"version" INT NOT NULL,
-	"created_at" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP
-);
-INSERT INTO "bitcoin_indexer_db_version" ("version") VALUES (1);
-
--- Bitcoin Data
-
-CREATE TABLE IF NOT EXISTS "bitcoin_blocks" (
-	"block_height" INT NOT NULL PRIMARY KEY,
-	"block_hash" TEXT NOT NULL,
-	"version" INT NOT NULL,
-	"merkle_root" TEXT NOT NULL,
-	"prev_block_hash" TEXT NOT NULL,
-	"timestamp" TIMESTAMP WITH TIME ZONE NOT NULL,
-	"bits" BIGINT NOT NULL,
-	"nonce" BIGINT NOT NULL
-);
-
-CREATE INDEX IF NOT EXISTS bitcoin_blocks_block_hash_idx ON "bitcoin_blocks" USING HASH ("block_hash");
-
-CREATE TABLE IF NOT EXISTS "bitcoin_transactions" (
-	"tx_hash" TEXT NOT NULL, -- can't use as primary key because block v1 has duplicate tx hashes (coinbase tx). See: https://github.com/bitcoin/bitcoin/commit/a206b0ea12eb4606b93323268fc81a4f1f952531
-	"version" INT NOT NULL,
-	"locktime" BIGINT NOT NULL,
-	"block_height" INT NOT NULL,
-	"block_hash" TEXT NOT NULL,
-	"idx" INT NOT NULL,
-	PRIMARY KEY ("block_height", "idx")
-);
-
-CREATE INDEX IF NOT EXISTS bitcoin_transactions_tx_hash_idx ON "bitcoin_transactions" USING HASH ("tx_hash");
-CREATE INDEX IF NOT EXISTS bitcoin_transactions_block_hash_idx ON "bitcoin_transactions" USING HASH ("block_hash");
-
-CREATE TABLE IF NOT EXISTS "bitcoin_transaction_txouts" (
-	"tx_hash" TEXT NOT NULL,
-	"tx_idx" INT NOT NULL,
-	"pkscript" TEXT NOT NULL, -- Hex String
-	"value" BIGINT NOT NULL,
-	"is_spent" BOOLEAN NOT NULL DEFAULT false,
-	PRIMARY KEY ("tx_hash", "tx_idx")
-);
-
-CREATE INDEX IF NOT EXISTS bitcoin_transaction_txouts_pkscript_idx ON "bitcoin_transaction_txouts" USING HASH ("pkscript");
-
-CREATE TABLE IF NOT EXISTS "bitcoin_transaction_txins" (
-	"tx_hash" TEXT NOT NULL,
-	"tx_idx" INT NOT NULL,
-	"prevout_tx_hash" TEXT NOT NULL,
-	"prevout_tx_idx" INT NOT NULL,
-	"prevout_pkscript" TEXT NULL, -- Hex String, Can be NULL if the prevout is a coinbase transaction
-	"scriptsig" TEXT NOT NULL, -- Hex String
-	"witness" TEXT NOT NULL DEFAULT '', -- Hex String
-	"sequence" BIGINT NOT NULL,
-	PRIMARY KEY ("tx_hash", "tx_idx")
-);
-
-CREATE INDEX IF NOT EXISTS bitcoin_transaction_txins_prevout_idx ON "bitcoin_transaction_txins" USING BTREE ("prevout_tx_hash", "prevout_tx_idx");
-
-COMMIT;

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

@@ -1,99 +0,0 @@
--- name: GetLatestBlockHeader :one
-SELECT * FROM bitcoin_blocks ORDER BY block_height DESC LIMIT 1;
-
--- name: InsertBlock :exec
-INSERT INTO bitcoin_blocks ("block_height","block_hash","version","merkle_root","prev_block_hash","timestamp","bits","nonce") VALUES ($1, $2, $3, $4, $5, $6, $7, $8);
-
--- name: BatchInsertBlocks :exec
-INSERT INTO bitcoin_blocks ("block_height","block_hash","version","merkle_root","prev_block_hash","timestamp","bits","nonce")
-VALUES (
-	unnest(@block_height_arr::INT[]),
-	unnest(@block_hash_arr::TEXT[]),
-	unnest(@version_arr::INT[]),
-	unnest(@merkle_root_arr::TEXT[]),
-	unnest(@prev_block_hash_arr::TEXT[]),
-	unnest(@timestamp_arr::TIMESTAMP WITH TIME ZONE[]), -- or use TIMESTAMPTZ
-	unnest(@bits_arr::BIGINT[]),
-	unnest(@nonce_arr::BIGINT[])
-);
-
--- name: BatchInsertTransactions :exec
-INSERT INTO bitcoin_transactions ("tx_hash","version","locktime","block_height","block_hash","idx")
-VALUES (
-	unnest(@tx_hash_arr::TEXT[]),
-	unnest(@version_arr::INT[]),
-	unnest(@locktime_arr::BIGINT[]),
-	unnest(@block_height_arr::INT[]),
-	unnest(@block_hash_arr::TEXT[]),
-	unnest(@idx_arr::INT[])
-);
-
--- name: BatchInsertTransactionTxIns :exec
-WITH update_txout AS (
-	UPDATE "bitcoin_transaction_txouts"
-	SET "is_spent" = true
-	FROM (SELECT unnest(@prevout_tx_hash_arr::TEXT[]) as tx_hash, unnest(@prevout_tx_idx_arr::INT[]) as tx_idx) as txin
-	WHERE "bitcoin_transaction_txouts"."tx_hash" = txin.tx_hash AND "bitcoin_transaction_txouts"."tx_idx" = txin.tx_idx AND "is_spent" = false
-	RETURNING "bitcoin_transaction_txouts"."tx_hash", "bitcoin_transaction_txouts"."tx_idx", "pkscript"
-), prepare_insert AS (
-	SELECT input.tx_hash, input.tx_idx, prevout_tx_hash, prevout_tx_idx, update_txout.pkscript as prevout_pkscript, scriptsig, witness, sequence
-		FROM (
-			SELECT 
-				unnest(@tx_hash_arr::TEXT[]) as tx_hash,
-				unnest(@tx_idx_arr::INT[]) as tx_idx,
-				unnest(@prevout_tx_hash_arr::TEXT[]) as prevout_tx_hash,
-				unnest(@prevout_tx_idx_arr::INT[]) as prevout_tx_idx,
-				unnest(@scriptsig_arr::TEXT[]) as scriptsig,
-				unnest(@witness_arr::TEXT[]) as witness,
-				unnest(@sequence_arr::INT[]) as sequence
-		) input LEFT JOIN update_txout ON "update_txout"."tx_hash" = "input"."prevout_tx_hash" AND "update_txout"."tx_idx" = "input"."prevout_tx_idx"
-)
-INSERT INTO bitcoin_transaction_txins ("tx_hash","tx_idx","prevout_tx_hash","prevout_tx_idx", "prevout_pkscript","scriptsig","witness","sequence") 
-SELECT "tx_hash", "tx_idx", "prevout_tx_hash", "prevout_tx_idx", "prevout_pkscript", "scriptsig", "witness", "sequence" FROM prepare_insert;
-
--- name: BatchInsertTransactionTxOuts :exec
-INSERT INTO bitcoin_transaction_txouts ("tx_hash","tx_idx","pkscript","value")
-VALUES (
-	unnest(@tx_hash_arr::TEXT[]),
-	unnest(@tx_idx_arr::INT[]),
-	unnest(@pkscript_arr::TEXT[]),
-	unnest(@value_arr::BIGINT[])
-);
-
--- name: RevertData :exec
-WITH delete_tx AS (
-	DELETE FROM "bitcoin_transactions" WHERE "block_height" >= @from_height
-	RETURNING "tx_hash"
-), delete_txin AS (
-	DELETE FROM  "bitcoin_transaction_txins" WHERE "tx_hash" = ANY(SELECT "tx_hash" FROM delete_tx)
-	RETURNING "prevout_tx_hash", "prevout_tx_idx"
-), delete_txout AS (
-	DELETE FROM  "bitcoin_transaction_txouts" WHERE "tx_hash" = ANY(SELECT "tx_hash" FROM delete_tx)
-	RETURNING "tx_hash", "tx_idx"
-), revert_txout_spent AS (
-	UPDATE "bitcoin_transaction_txouts"
-	SET "is_spent" = false
-	WHERE 
-		("tx_hash", "tx_idx") IN (SELECT "prevout_tx_hash", "prevout_tx_idx" FROM delete_txin) AND 
-		("tx_hash", "tx_idx") NOT IN (SELECT "tx_hash", "tx_idx" FROM delete_txout) -- avoid to modified same row twice (modified the same row twice in a single statement is not supported)
-	RETURNING NULL
-)
-DELETE FROM "bitcoin_blocks" WHERE "bitcoin_blocks"."block_height" >= @from_height;
-
--- name: GetBlockByHeight :one
-SELECT * FROM bitcoin_blocks WHERE block_height = $1;
-
--- name: GetBlocksByHeightRange :many
-SELECT * FROM bitcoin_blocks WHERE block_height >= @from_height AND block_height <= @to_height ORDER BY block_height ASC;
-
--- name: GetTransactionsByHeightRange :many
-SELECT * FROM bitcoin_transactions WHERE block_height >= @from_height AND block_height <= @to_height;
-
--- name: GetTransactionByHash :one
-SELECT * FROM bitcoin_transactions WHERE tx_hash = $1;
-
--- name: GetTransactionTxOutsByTxHashes :many
-SELECT * FROM bitcoin_transaction_txouts WHERE tx_hash = ANY(@tx_hashes::TEXT[]);
-
--- name: GetTransactionTxInsByTxHashes :many
-SELECT * FROM bitcoin_transaction_txins WHERE tx_hash = ANY(@tx_hashes::TEXT[]);

modules/bitcoin/database/postgresql/queries/info.sql

@@ -1,8 +0,0 @@
--- name: GetCurrentDBVersion :one
-SELECT "version" FROM bitcoin_indexer_db_version ORDER BY id DESC LIMIT 1;
-
--- name: GetCurrentIndexerStats :one
-SELECT "client_version", "network" FROM bitcoin_indexer_stats ORDER BY id DESC LIMIT 1;
-
--- name: UpdateIndexerStats :exec
-INSERT INTO bitcoin_indexer_stats (client_version, network) VALUES ($1, $2);

modules/bitcoin/datagateway/bitcoin_data.go

@@ -1,25 +0,0 @@
-package datagateway
-
-import (
-	"context"
-
-	"github.com/btcsuite/btcd/chaincfg/chainhash"
-	"github.com/gaze-network/indexer-network/core/types"
-)
-
-type BitcoinDataGateway interface {
-	BitcoinWriterDataDataGateway
-	BitcoinReaderDataDataGateway
-}
-
-type BitcoinWriterDataDataGateway interface {
-	InsertBlocks(ctx context.Context, blocks []*types.Block) error
-	RevertBlocks(context.Context, int64) error
-}
-
-type BitcoinReaderDataDataGateway interface {
-	GetLatestBlockHeader(context.Context) (types.BlockHeader, error)
-	GetBlockHeaderByHeight(ctx context.Context, blockHeight int64) (types.BlockHeader, error)
-	GetBlocksByHeightRange(ctx context.Context, from int64, to int64) ([]*types.Block, error)
-	GetTransactionByHash(ctx context.Context, txHash chainhash.Hash) (*types.Transaction, error)
-}

modules/bitcoin/datagateway/indexer_info.go

@@ -1,13 +0,0 @@
-package datagateway
-
-import (
-	"context"
-
-	"github.com/gaze-network/indexer-network/common"
-)
-
-type IndexerInformationDataGateway interface {
-	GetCurrentDBVersion(ctx context.Context) (int32, error)
-	GetLatestIndexerStats(ctx context.Context) (version string, network common.Network, err error)
-	UpdateIndexerStats(ctx context.Context, clientVersion string, network common.Network) error
-}

modules/bitcoin/processor.go

@@ -1,122 +0,0 @@
-package bitcoin
-
-import (
-	"context"
-
-	"github.com/cockroachdb/errors"
-	"github.com/gaze-network/indexer-network/common/errs"
-	"github.com/gaze-network/indexer-network/core/indexers"
-	"github.com/gaze-network/indexer-network/core/types"
-	"github.com/gaze-network/indexer-network/internal/config"
-	"github.com/gaze-network/indexer-network/modules/bitcoin/datagateway"
-)
-
-// Make sure to implement the BitcoinProcessor interface
-var _ indexers.BitcoinProcessor = (*Processor)(nil)
-
-type Processor struct {
-	config        config.Config
-	bitcoinDg     datagateway.BitcoinDataGateway
-	indexerInfoDg datagateway.IndexerInformationDataGateway
-}
-
-func NewProcessor(config config.Config, bitcoinDg datagateway.BitcoinDataGateway, indexerInfoDg datagateway.IndexerInformationDataGateway) *Processor {
-	return &Processor{
-		config:        config,
-		bitcoinDg:     bitcoinDg,
-		indexerInfoDg: indexerInfoDg,
-	}
-}
-
-func (p Processor) Name() string {
-	return "bitcoin"
-}
-
-func (p *Processor) Process(ctx context.Context, inputs []*types.Block) error {
-	if len(inputs) == 0 {
-		return nil
-	}
-
-	// Process the given blocks before inserting to the database
-	inputs, err := p.process(ctx, inputs)
-	if err != nil {
-		return errors.WithStack(err)
-	}
-
-	// Insert blocks
-	if err := p.bitcoinDg.InsertBlocks(ctx, inputs); err != nil {
-		return errors.Wrapf(err, "error during insert blocks, from: %d, to: %d", inputs[0].Header.Height, inputs[len(inputs)-1].Header.Height)
-	}
-
-	return nil
-}
-
-func (p *Processor) CurrentBlock(ctx context.Context) (types.BlockHeader, error) {
-	b, err := p.bitcoinDg.GetLatestBlockHeader(ctx)
-	if err != nil {
-		if errors.Is(err, errs.NotFound) {
-			return defaultCurrentBlock, nil
-		}
-		return types.BlockHeader{}, errors.WithStack(err)
-	}
-	return b, nil
-}
-
-func (p *Processor) GetIndexedBlock(ctx context.Context, height int64) (types.BlockHeader, error) {
-	header, err := p.bitcoinDg.GetBlockHeaderByHeight(ctx, height)
-	if err != nil {
-		return types.BlockHeader{}, errors.WithStack(err)
-	}
-	return header, nil
-}
-
-func (p *Processor) RevertData(ctx context.Context, from int64) error {
-	// to prevent remove txin/txout of duplicated coinbase transaction in the blocks 91842 and 91880
-	// if you really want to revert the data before the block `227835`, you should reset the database and reindex the data instead.
-	if from <= lastV1Block.Height {
-		return errors.Wrapf(errs.InvalidArgument, "can't revert data before block version 2, height: %d", lastV1Block.Height)
-	}
-
-	if err := p.bitcoinDg.RevertBlocks(ctx, from); err != nil {
-		return errors.WithStack(err)
-	}
-	return nil
-}
-
-func (p *Processor) VerifyStates(ctx context.Context) error {
-	// Check current db version with the required db version
-	{
-		dbVersion, err := p.indexerInfoDg.GetCurrentDBVersion(ctx)
-		if err != nil {
-			return errors.Wrap(err, "can't get current db version")
-		}
-
-		if dbVersion != DBVersion {
-			return errors.Wrapf(errs.ConflictSetting, "db version mismatch, please upgrade to version %d", DBVersion)
-		}
-	}
-
-	// Check if the latest indexed network is mismatched with configured network
-	{
-		_, network, err := p.indexerInfoDg.GetLatestIndexerStats(ctx)
-		if err != nil {
-			if errors.Is(err, errs.NotFound) {
-				goto end
-			}
-			return errors.Wrap(err, "can't get latest indexer stats")
-		}
-
-		if network != p.config.Network {
-			return errors.Wrapf(errs.ConflictSetting, "network mismatch, latest indexed network: %q, configured network: %q. If you want to change the network, please reset the database", network, p.config.Network)
-		}
-	}
-
-	// TODO: Verify the states of the indexed data to ensure the last shutdown was graceful and no missing data.
-
-end:
-	if err := p.indexerInfoDg.UpdateIndexerStats(ctx, Version, p.config.Network); err != nil {
-		return errors.Wrap(err, "can't update indexer stats")
-	}
-
-	return nil
-}

modules/bitcoin/processor_process.go

@@ -1,91 +0,0 @@
-package bitcoin
-
-import (
-	"cmp"
-	"context"
-	"slices"
-
-	"github.com/cockroachdb/errors"
-	"github.com/gaze-network/indexer-network/core/types"
-)
-
-// process is a processing rules for the given blocks before inserting to the database
-//
-// this function will modify the given data directly.
-func (p *Processor) process(ctx context.Context, blocks []*types.Block) ([]*types.Block, error) {
-	if len(blocks) == 0 {
-		return blocks, nil
-	}
-
-	// Sort ASC by block height
-	slices.SortFunc(blocks, func(t1, t2 *types.Block) int {
-		return cmp.Compare(t1.Header.Height, t2.Header.Height)
-	})
-
-	if !p.isContinueFromLatestIndexedBlock(ctx, blocks[0]) {
-		return nil, errors.New("given blocks are not continue from the latest indexed block")
-	}
-
-	if !p.isBlocksSequential(blocks) {
-		return nil, errors.New("given blocks are not in sequence")
-	}
-
-	p.removeDuplicateCoinbaseTxInputsOutputs(blocks)
-
-	return blocks, nil
-}
-
-// check if the given blocks are continue from the latest indexed block
-// to prevent inserting out-of-order blocks or duplicate blocks
-func (p *Processor) isBlocksSequential(blocks []*types.Block) bool {
-	if len(blocks) == 0 {
-		return true
-	}
-
-	for i, block := range blocks {
-		if i == 0 {
-			continue
-		}
-
-		if block.Header.Height != blocks[i-1].Header.Height+1 {
-			return false
-		}
-	}
-
-	return true
-}
-
-// check if the given blocks are continue from the latest indexed block
-// to prevent inserting out-of-order blocks or duplicate blocks
-func (p *Processor) isContinueFromLatestIndexedBlock(ctx context.Context, block *types.Block) bool {
-	latestBlock, err := p.CurrentBlock(ctx)
-	if err != nil {
-		return false
-	}
-
-	return block.Header.Height == latestBlock.Height+1
-}
-
-// there 2 coinbase transaction that are duplicated in the blocks 91842 and 91880.
-// if the given block version is v1 and height is `91842` or `91880`,
-// then remove transaction inputs/outputs to prevent duplicate txin/txout error when inserting to the database.
-//
-// Theses duplicated coinbase transactions are having the same transaction input/output and
-// utxo from these 2 duplicated coinbase txs can redeem only once. so, it's safe to remove them and can
-// use inputs/outputs from the previous block.
-//
-// Duplicate Coinbase Transactions:
-//   - `454279874213763724535987336644243549a273058910332236515429488599` in blocks 91812, 91842
-//   - `e3bf3d07d4b0375638d5f1db5255fe07ba2c4cb067cd81b84ee974b6585fb468` in blocks 91722, 91880
-//
-// This function will modify the given data directly.
-func (p *Processor) removeDuplicateCoinbaseTxInputsOutputs(blocks []*types.Block) {
-	for _, block := range blocks {
-		header := block.Header
-		if header.Version == 1 && (header.Height == 91842 || header.Height == 91880) {
-			// remove transaction inputs/outputs from coinbase transaction (first transaction)
-			block.Transactions[0].TxIn = nil
-			block.Transactions[0].TxOut = nil
-		}
-	}
-}

modules/bitcoin/processor_process_test.go

@@ -1,144 +0,0 @@
-package bitcoin
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/gaze-network/indexer-network/core/types"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestDuplicateCoinbaseTxHashHandling(t *testing.T) {
-	processor := Processor{}
-	generator := func() []*types.Block {
-		return []*types.Block{
-			{
-				Header: types.BlockHeader{Height: 91842, Version: 1},
-				Transactions: []*types.Transaction{
-					{
-						TxIn:  []*types.TxIn{{}, {}, {}, {}},
-						TxOut: []*types.TxOut{{}, {}, {}, {}},
-					},
-					{
-						TxIn:  []*types.TxIn{{}, {}, {}, {}},
-						TxOut: []*types.TxOut{{}, {}, {}, {}},
-					},
-				},
-			},
-			{
-				Header: types.BlockHeader{Height: 91880, Version: 1},
-				Transactions: []*types.Transaction{
-					{
-						TxIn:  []*types.TxIn{{}, {}, {}, {}},
-						TxOut: []*types.TxOut{{}, {}, {}, {}},
-					},
-					{
-						TxIn:  []*types.TxIn{{}, {}, {}, {}},
-						TxOut: []*types.TxOut{{}, {}, {}, {}},
-					},
-				},
-			},
-		}
-	}
-
-	t.Run("all_duplicated_txs", func(t *testing.T) {
-		blocks := generator()
-		processor.removeDuplicateCoinbaseTxInputsOutputs(blocks)
-
-		assert.Len(t, blocks, 2, "should not remove any blocks")
-		for _, block := range blocks {
-			assert.Len(t, block.Transactions, 2, "should not remove any transactions")
-			assert.Len(t, block.Transactions[0].TxIn, 0, "should remove tx inputs from coinbase transaction")
-			assert.Len(t, block.Transactions[0].TxOut, 0, "should remove tx outputs from coinbase transaction")
-		}
-	})
-
-	t.Run("not_duplicated_txs", func(t *testing.T) {
-		blocks := []*types.Block{
-			{
-				Header: types.BlockHeader{Height: 91812, Version: 1},
-				Transactions: []*types.Transaction{
-					{
-						TxIn:  []*types.TxIn{{}, {}, {}, {}},
-						TxOut: []*types.TxOut{{}, {}, {}, {}},
-					},
-					{
-						TxIn:  []*types.TxIn{{}, {}, {}, {}},
-						TxOut: []*types.TxOut{{}, {}, {}, {}},
-					},
-				},
-			},
-			{
-				Header: types.BlockHeader{Height: 91722, Version: 1},
-				Transactions: []*types.Transaction{
-					{
-						TxIn:  []*types.TxIn{{}, {}, {}, {}},
-						TxOut: []*types.TxOut{{}, {}, {}, {}},
-					},
-					{
-						TxIn:  []*types.TxIn{{}, {}, {}, {}},
-						TxOut: []*types.TxOut{{}, {}, {}, {}},
-					},
-				},
-			},
-		}
-		processor.removeDuplicateCoinbaseTxInputsOutputs(blocks)
-
-		assert.Len(t, blocks, 2, "should not remove any blocks")
-		for _, block := range blocks {
-			assert.Len(t, block.Transactions, 2, "should not remove any transactions")
-			assert.Len(t, block.Transactions[0].TxIn, 4, "should not remove tx inputs from coinbase transaction")
-			assert.Len(t, block.Transactions[0].TxOut, 4, "should not remove tx outputs from coinbase transaction")
-		}
-	})
-
-	t.Run("mixed", func(t *testing.T) {
-		blocks := []*types.Block{
-			{
-				Header: types.BlockHeader{Height: 91812, Version: 1},
-				Transactions: []*types.Transaction{
-					{
-						TxIn:  []*types.TxIn{{}, {}, {}, {}},
-						TxOut: []*types.TxOut{{}, {}, {}, {}},
-					},
-					{
-						TxIn:  []*types.TxIn{{}, {}, {}, {}},
-						TxOut: []*types.TxOut{{}, {}, {}, {}},
-					},
-				},
-			},
-		}
-		blocks = append(blocks, generator()...)
-		blocks = append(blocks, &types.Block{
-			Header: types.BlockHeader{Height: 91722, Version: 1},
-			Transactions: []*types.Transaction{
-				{
-					TxIn:  []*types.TxIn{{}, {}, {}, {}},
-					TxOut: []*types.TxOut{{}, {}, {}, {}},
-				},
-				{
-					TxIn:  []*types.TxIn{{}, {}, {}, {}},
-					TxOut: []*types.TxOut{{}, {}, {}, {}},
-				},
-			},
-		})
-		processor.removeDuplicateCoinbaseTxInputsOutputs(blocks)
-
-		assert.Len(t, blocks, 4, "should not remove any blocks")
-
-		// only 2nd and 3rd blocks should be modified
-		for i, block := range blocks {
-			t.Run(fmt.Sprint(i), func(t *testing.T) {
-				if i == 1 || i == 2 {
-					assert.Len(t, block.Transactions, 2, "should not remove any transactions")
-					assert.Len(t, block.Transactions[0].TxIn, 0, "should remove tx inputs from coinbase transaction")
-					assert.Len(t, block.Transactions[0].TxOut, 0, "should remove tx outputs from coinbase transaction")
-				} else {
-					assert.Len(t, block.Transactions, 2, "should not remove any transactions")
-					assert.Lenf(t, block.Transactions[0].TxIn, 4, "should not remove tx inputs from coinbase transaction")
-					assert.Len(t, block.Transactions[0].TxOut, 4, "should not remove tx outputs from coinbase transaction")
-				}
-			})
-		}
-	})
-}

modules/bitcoin/repository/postgres/block.go

@@ -1,169 +0,0 @@
-package postgres
-
-import (
-	"context"
-
-	"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/bitcoin/repository/postgres/gen"
-	"github.com/jackc/pgx/v5"
-	"github.com/samber/lo"
-)
-
-func (r *Repository) GetLatestBlockHeader(ctx context.Context) (types.BlockHeader, error) {
-	model, err := r.queries.GetLatestBlockHeader(ctx)
-	if err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return types.BlockHeader{}, errors.Join(errs.NotFound, err)
-		}
-		return types.BlockHeader{}, errors.Wrap(err, "failed to get latest block header")
-	}
-
-	data, err := mapBlockHeaderModelToType(model)
-	if err != nil {
-		return types.BlockHeader{}, errors.Wrap(err, "failed to map block header model to type")
-	}
-
-	return data, nil
-}
-
-func (r *Repository) InsertBlocks(ctx context.Context, blocks []*types.Block) error {
-	if len(blocks) == 0 {
-		return nil
-	}
-
-	blockParams, txParams, txoutParams, txinParams := mapBlocksTypeToParams(blocks)
-
-	tx, err := r.db.Begin(ctx)
-	if err != nil {
-		return errors.Wrap(err, "failed to begin transaction")
-	}
-	defer tx.Rollback(ctx)
-
-	queries := r.queries.WithTx(tx)
-
-	if err := queries.BatchInsertBlocks(ctx, blockParams); err != nil {
-		return errors.Wrap(err, "failed to batch insert block headers")
-	}
-
-	if err := queries.BatchInsertTransactions(ctx, txParams); err != nil {
-		return errors.Wrap(err, "failed to batch insert transactions")
-	}
-
-	// Should insert txout first, then txin
-	// Because txin references txout
-	if err := queries.BatchInsertTransactionTxOuts(ctx, txoutParams); err != nil {
-		return errors.Wrap(err, "failed to batch insert transaction txins")
-	}
-
-	if err := queries.BatchInsertTransactionTxIns(ctx, txinParams); err != nil {
-		return errors.Wrap(err, "failed to batch insert transaction txins")
-	}
-
-	if err := tx.Commit(ctx); err != nil {
-		return errors.Wrap(err, "failed to commit transaction")
-	}
-
-	return nil
-}
-
-func (r *Repository) RevertBlocks(ctx context.Context, from int64) error {
-	tx, err := r.db.Begin(ctx)
-	if err != nil {
-		return errors.Wrap(err, "failed to begin transaction")
-	}
-	defer tx.Rollback(ctx)
-
-	queries := r.queries.WithTx(tx)
-	if err := queries.RevertData(ctx, int32(from)); err != nil && !errors.Is(err, pgx.ErrNoRows) {
-		return errors.Wrap(err, "failed to revert data")
-	}
-
-	if err := tx.Commit(ctx); err != nil {
-		return errors.Wrap(err, "failed to commit transaction")
-	}
-
-	return nil
-}
-
-func (r *Repository) GetBlockHeaderByHeight(ctx context.Context, blockHeight int64) (types.BlockHeader, error) {
-	blockModel, err := r.queries.GetBlockByHeight(ctx, int32(blockHeight))
-	if err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return types.BlockHeader{}, errors.Join(errs.NotFound, err)
-		}
-		return types.BlockHeader{}, errors.Wrap(err, "failed to get block by height")
-	}
-
-	data, err := mapBlockHeaderModelToType(blockModel)
-	if err != nil {
-		return types.BlockHeader{}, errors.Wrap(err, "failed to map block header model to type")
-	}
-	return data, nil
-}
-
-func (r *Repository) GetBlocksByHeightRange(ctx context.Context, from int64, to int64) ([]*types.Block, error) {
-	blocks, err := r.queries.GetBlocksByHeightRange(ctx, gen.GetBlocksByHeightRangeParams{
-		FromHeight: int32(from),
-		ToHeight:   int32(to),
-	})
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to get blocks by height range")
-	}
-
-	if len(blocks) == 0 {
-		return []*types.Block{}, nil
-	}
-
-	txs, err := r.queries.GetTransactionsByHeightRange(ctx, gen.GetTransactionsByHeightRangeParams{
-		FromHeight: int32(from),
-		ToHeight:   int32(to),
-	})
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to get transactions by height range")
-	}
-
-	txHashes := lo.Map(txs, func(tx gen.BitcoinTransaction, _ int) string { return tx.TxHash })
-
-	txOuts, err := r.queries.GetTransactionTxOutsByTxHashes(ctx, txHashes)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to get transaction txouts by tx hashes")
-	}
-
-	txIns, err := r.queries.GetTransactionTxInsByTxHashes(ctx, txHashes)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to get transaction txins by tx hashes")
-	}
-
-	// Grouping result by block height and tx hash
-	groupedTxs := lo.GroupBy(txs, func(tx gen.BitcoinTransaction) int32 { return tx.BlockHeight })
-	groupedTxOuts := lo.GroupBy(txOuts, func(txOut gen.BitcoinTransactionTxout) string { return txOut.TxHash })
-	groupedTxIns := lo.GroupBy(txIns, func(txIn gen.BitcoinTransactionTxin) string { return txIn.TxHash })
-
-	var errs []error
-	result := lo.Map(blocks, func(blockModel gen.BitcoinBlock, _ int) *types.Block {
-		header, err := mapBlockHeaderModelToType(blockModel)
-		if err != nil {
-			errs = append(errs, errors.Wrap(err, "failed to map block header model to type"))
-			return nil
-		}
-
-		txsModel := groupedTxs[blockModel.BlockHeight]
-		return &types.Block{
-			Header: header,
-			Transactions: lo.Map(txsModel, func(txModel gen.BitcoinTransaction, _ int) *types.Transaction {
-				tx, err := mapTransactionModelToType(txModel, groupedTxIns[txModel.TxHash], groupedTxOuts[txModel.TxHash])
-				if err != nil {
-					errs = append(errs, errors.Wrap(err, "failed to map transaction model to type"))
-					return nil
-				}
-				return &tx
-			}),
-		}
-	})
-	if len(errs) > 0 {
-		return nil, errors.Wrap(errors.Join(errs...), "failed while mapping result")
-	}
-	return result, nil
-}

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

@@ -1,408 +0,0 @@
-// Code generated by sqlc. DO NOT EDIT.
-// versions:
-//   sqlc v1.26.0
-// source: data.sql
-
-package gen
-
-import (
-	"context"
-
-	"github.com/jackc/pgx/v5/pgtype"
-)
-
-const batchInsertBlocks = `-- name: BatchInsertBlocks :exec
-INSERT INTO bitcoin_blocks ("block_height","block_hash","version","merkle_root","prev_block_hash","timestamp","bits","nonce")
-VALUES (
-	unnest($1::INT[]),
-	unnest($2::TEXT[]),
-	unnest($3::INT[]),
-	unnest($4::TEXT[]),
-	unnest($5::TEXT[]),
-	unnest($6::TIMESTAMP WITH TIME ZONE[]), -- or use TIMESTAMPTZ
-	unnest($7::BIGINT[]),
-	unnest($8::BIGINT[])
-)
-`
-
-type BatchInsertBlocksParams struct {
-	BlockHeightArr   []int32
-	BlockHashArr     []string
-	VersionArr       []int32
-	MerkleRootArr    []string
-	PrevBlockHashArr []string
-	TimestampArr     []pgtype.Timestamptz
-	BitsArr          []int64
-	NonceArr         []int64
-}
-
-func (q *Queries) BatchInsertBlocks(ctx context.Context, arg BatchInsertBlocksParams) error {
-	_, err := q.db.Exec(ctx, batchInsertBlocks,
-		arg.BlockHeightArr,
-		arg.BlockHashArr,
-		arg.VersionArr,
-		arg.MerkleRootArr,
-		arg.PrevBlockHashArr,
-		arg.TimestampArr,
-		arg.BitsArr,
-		arg.NonceArr,
-	)
-	return err
-}
-
-const batchInsertTransactionTxIns = `-- name: BatchInsertTransactionTxIns :exec
-WITH update_txout AS (
-	UPDATE "bitcoin_transaction_txouts"
-	SET "is_spent" = true
-	FROM (SELECT unnest($1::TEXT[]) as tx_hash, unnest($2::INT[]) as tx_idx) as txin
-	WHERE "bitcoin_transaction_txouts"."tx_hash" = txin.tx_hash AND "bitcoin_transaction_txouts"."tx_idx" = txin.tx_idx AND "is_spent" = false
-	RETURNING "bitcoin_transaction_txouts"."tx_hash", "bitcoin_transaction_txouts"."tx_idx", "pkscript"
-), prepare_insert AS (
-	SELECT input.tx_hash, input.tx_idx, prevout_tx_hash, prevout_tx_idx, update_txout.pkscript as prevout_pkscript, scriptsig, witness, sequence
-		FROM (
-			SELECT 
-				unnest($3::TEXT[]) as tx_hash,
-				unnest($4::INT[]) as tx_idx,
-				unnest($1::TEXT[]) as prevout_tx_hash,
-				unnest($2::INT[]) as prevout_tx_idx,
-				unnest($5::TEXT[]) as scriptsig,
-				unnest($6::TEXT[]) as witness,
-				unnest($7::INT[]) as sequence
-		) input LEFT JOIN update_txout ON "update_txout"."tx_hash" = "input"."prevout_tx_hash" AND "update_txout"."tx_idx" = "input"."prevout_tx_idx"
-)
-INSERT INTO bitcoin_transaction_txins ("tx_hash","tx_idx","prevout_tx_hash","prevout_tx_idx", "prevout_pkscript","scriptsig","witness","sequence") 
-SELECT "tx_hash", "tx_idx", "prevout_tx_hash", "prevout_tx_idx", "prevout_pkscript", "scriptsig", "witness", "sequence" FROM prepare_insert
-`
-
-type BatchInsertTransactionTxInsParams struct {
-	PrevoutTxHashArr []string
-	PrevoutTxIdxArr  []int32
-	TxHashArr        []string
-	TxIdxArr         []int32
-	ScriptsigArr     []string
-	WitnessArr       []string
-	SequenceArr      []int32
-}
-
-func (q *Queries) BatchInsertTransactionTxIns(ctx context.Context, arg BatchInsertTransactionTxInsParams) error {
-	_, err := q.db.Exec(ctx, batchInsertTransactionTxIns,
-		arg.PrevoutTxHashArr,
-		arg.PrevoutTxIdxArr,
-		arg.TxHashArr,
-		arg.TxIdxArr,
-		arg.ScriptsigArr,
-		arg.WitnessArr,
-		arg.SequenceArr,
-	)
-	return err
-}
-
-const batchInsertTransactionTxOuts = `-- name: BatchInsertTransactionTxOuts :exec
-INSERT INTO bitcoin_transaction_txouts ("tx_hash","tx_idx","pkscript","value")
-VALUES (
-	unnest($1::TEXT[]),
-	unnest($2::INT[]),
-	unnest($3::TEXT[]),
-	unnest($4::BIGINT[])
-)
-`
-
-type BatchInsertTransactionTxOutsParams struct {
-	TxHashArr   []string
-	TxIdxArr    []int32
-	PkscriptArr []string
-	ValueArr    []int64
-}
-
-func (q *Queries) BatchInsertTransactionTxOuts(ctx context.Context, arg BatchInsertTransactionTxOutsParams) error {
-	_, err := q.db.Exec(ctx, batchInsertTransactionTxOuts,
-		arg.TxHashArr,
-		arg.TxIdxArr,
-		arg.PkscriptArr,
-		arg.ValueArr,
-	)
-	return err
-}
-
-const batchInsertTransactions = `-- name: BatchInsertTransactions :exec
-INSERT INTO bitcoin_transactions ("tx_hash","version","locktime","block_height","block_hash","idx")
-VALUES (
-	unnest($1::TEXT[]),
-	unnest($2::INT[]),
-	unnest($3::BIGINT[]),
-	unnest($4::INT[]),
-	unnest($5::TEXT[]),
-	unnest($6::INT[])
-)
-`
-
-type BatchInsertTransactionsParams struct {
-	TxHashArr      []string
-	VersionArr     []int32
-	LocktimeArr    []int64
-	BlockHeightArr []int32
-	BlockHashArr   []string
-	IdxArr         []int32
-}
-
-func (q *Queries) BatchInsertTransactions(ctx context.Context, arg BatchInsertTransactionsParams) error {
-	_, err := q.db.Exec(ctx, batchInsertTransactions,
-		arg.TxHashArr,
-		arg.VersionArr,
-		arg.LocktimeArr,
-		arg.BlockHeightArr,
-		arg.BlockHashArr,
-		arg.IdxArr,
-	)
-	return err
-}
-
-const getBlockByHeight = `-- name: GetBlockByHeight :one
-SELECT block_height, block_hash, version, merkle_root, prev_block_hash, timestamp, bits, nonce FROM bitcoin_blocks WHERE block_height = $1
-`
-
-func (q *Queries) GetBlockByHeight(ctx context.Context, blockHeight int32) (BitcoinBlock, error) {
-	row := q.db.QueryRow(ctx, getBlockByHeight, blockHeight)
-	var i BitcoinBlock
-	err := row.Scan(
-		&i.BlockHeight,
-		&i.BlockHash,
-		&i.Version,
-		&i.MerkleRoot,
-		&i.PrevBlockHash,
-		&i.Timestamp,
-		&i.Bits,
-		&i.Nonce,
-	)
-	return i, err
-}
-
-const getBlocksByHeightRange = `-- name: GetBlocksByHeightRange :many
-SELECT block_height, block_hash, version, merkle_root, prev_block_hash, timestamp, bits, nonce FROM bitcoin_blocks WHERE block_height >= $1 AND block_height <= $2 ORDER BY block_height ASC
-`
-
-type GetBlocksByHeightRangeParams struct {
-	FromHeight int32
-	ToHeight   int32
-}
-
-func (q *Queries) GetBlocksByHeightRange(ctx context.Context, arg GetBlocksByHeightRangeParams) ([]BitcoinBlock, error) {
-	rows, err := q.db.Query(ctx, getBlocksByHeightRange, arg.FromHeight, arg.ToHeight)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var items []BitcoinBlock
-	for rows.Next() {
-		var i BitcoinBlock
-		if err := rows.Scan(
-			&i.BlockHeight,
-			&i.BlockHash,
-			&i.Version,
-			&i.MerkleRoot,
-			&i.PrevBlockHash,
-			&i.Timestamp,
-			&i.Bits,
-			&i.Nonce,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const getLatestBlockHeader = `-- name: GetLatestBlockHeader :one
-SELECT block_height, block_hash, version, merkle_root, prev_block_hash, timestamp, bits, nonce FROM bitcoin_blocks ORDER BY block_height DESC LIMIT 1
-`
-
-func (q *Queries) GetLatestBlockHeader(ctx context.Context) (BitcoinBlock, error) {
-	row := q.db.QueryRow(ctx, getLatestBlockHeader)
-	var i BitcoinBlock
-	err := row.Scan(
-		&i.BlockHeight,
-		&i.BlockHash,
-		&i.Version,
-		&i.MerkleRoot,
-		&i.PrevBlockHash,
-		&i.Timestamp,
-		&i.Bits,
-		&i.Nonce,
-	)
-	return i, err
-}
-
-const getTransactionByHash = `-- name: GetTransactionByHash :one
-SELECT tx_hash, version, locktime, block_height, block_hash, idx FROM bitcoin_transactions WHERE tx_hash = $1
-`
-
-func (q *Queries) GetTransactionByHash(ctx context.Context, txHash string) (BitcoinTransaction, error) {
-	row := q.db.QueryRow(ctx, getTransactionByHash, txHash)
-	var i BitcoinTransaction
-	err := row.Scan(
-		&i.TxHash,
-		&i.Version,
-		&i.Locktime,
-		&i.BlockHeight,
-		&i.BlockHash,
-		&i.Idx,
-	)
-	return i, err
-}
-
-const getTransactionTxInsByTxHashes = `-- name: GetTransactionTxInsByTxHashes :many
-SELECT tx_hash, tx_idx, prevout_tx_hash, prevout_tx_idx, prevout_pkscript, scriptsig, witness, sequence FROM bitcoin_transaction_txins WHERE tx_hash = ANY($1::TEXT[])
-`
-
-func (q *Queries) GetTransactionTxInsByTxHashes(ctx context.Context, txHashes []string) ([]BitcoinTransactionTxin, error) {
-	rows, err := q.db.Query(ctx, getTransactionTxInsByTxHashes, txHashes)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var items []BitcoinTransactionTxin
-	for rows.Next() {
-		var i BitcoinTransactionTxin
-		if err := rows.Scan(
-			&i.TxHash,
-			&i.TxIdx,
-			&i.PrevoutTxHash,
-			&i.PrevoutTxIdx,
-			&i.PrevoutPkscript,
-			&i.Scriptsig,
-			&i.Witness,
-			&i.Sequence,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const getTransactionTxOutsByTxHashes = `-- name: GetTransactionTxOutsByTxHashes :many
-SELECT tx_hash, tx_idx, pkscript, value, is_spent FROM bitcoin_transaction_txouts WHERE tx_hash = ANY($1::TEXT[])
-`
-
-func (q *Queries) GetTransactionTxOutsByTxHashes(ctx context.Context, txHashes []string) ([]BitcoinTransactionTxout, error) {
-	rows, err := q.db.Query(ctx, getTransactionTxOutsByTxHashes, txHashes)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var items []BitcoinTransactionTxout
-	for rows.Next() {
-		var i BitcoinTransactionTxout
-		if err := rows.Scan(
-			&i.TxHash,
-			&i.TxIdx,
-			&i.Pkscript,
-			&i.Value,
-			&i.IsSpent,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const getTransactionsByHeightRange = `-- name: GetTransactionsByHeightRange :many
-SELECT tx_hash, version, locktime, block_height, block_hash, idx FROM bitcoin_transactions WHERE block_height >= $1 AND block_height <= $2
-`
-
-type GetTransactionsByHeightRangeParams struct {
-	FromHeight int32
-	ToHeight   int32
-}
-
-func (q *Queries) GetTransactionsByHeightRange(ctx context.Context, arg GetTransactionsByHeightRangeParams) ([]BitcoinTransaction, error) {
-	rows, err := q.db.Query(ctx, getTransactionsByHeightRange, arg.FromHeight, arg.ToHeight)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var items []BitcoinTransaction
-	for rows.Next() {
-		var i BitcoinTransaction
-		if err := rows.Scan(
-			&i.TxHash,
-			&i.Version,
-			&i.Locktime,
-			&i.BlockHeight,
-			&i.BlockHash,
-			&i.Idx,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const insertBlock = `-- name: InsertBlock :exec
-INSERT INTO bitcoin_blocks ("block_height","block_hash","version","merkle_root","prev_block_hash","timestamp","bits","nonce") VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
-`
-
-type InsertBlockParams struct {
-	BlockHeight   int32
-	BlockHash     string
-	Version       int32
-	MerkleRoot    string
-	PrevBlockHash string
-	Timestamp     pgtype.Timestamptz
-	Bits          int64
-	Nonce         int64
-}
-
-func (q *Queries) InsertBlock(ctx context.Context, arg InsertBlockParams) error {
-	_, err := q.db.Exec(ctx, insertBlock,
-		arg.BlockHeight,
-		arg.BlockHash,
-		arg.Version,
-		arg.MerkleRoot,
-		arg.PrevBlockHash,
-		arg.Timestamp,
-		arg.Bits,
-		arg.Nonce,
-	)
-	return err
-}
-
-const revertData = `-- name: RevertData :exec
-WITH delete_tx AS (
-	DELETE FROM "bitcoin_transactions" WHERE "block_height" >= $1
-	RETURNING "tx_hash"
-), delete_txin AS (
-	DELETE FROM  "bitcoin_transaction_txins" WHERE "tx_hash" = ANY(SELECT "tx_hash" FROM delete_tx)
-	RETURNING "prevout_tx_hash", "prevout_tx_idx"
-), delete_txout AS (
-	DELETE FROM  "bitcoin_transaction_txouts" WHERE "tx_hash" = ANY(SELECT "tx_hash" FROM delete_tx)
-	RETURNING "tx_hash", "tx_idx"
-), revert_txout_spent AS (
-	UPDATE "bitcoin_transaction_txouts"
-	SET "is_spent" = false
-	WHERE 
-		("tx_hash", "tx_idx") IN (SELECT "prevout_tx_hash", "prevout_tx_idx" FROM delete_txin) AND 
-		("tx_hash", "tx_idx") NOT IN (SELECT "tx_hash", "tx_idx" FROM delete_txout) -- avoid to modified same row twice (modified the same row twice in a single statement is not supported)
-	RETURNING NULL
-)
-DELETE FROM "bitcoin_blocks" WHERE "bitcoin_blocks"."block_height" >= $1
-`
-
-func (q *Queries) RevertData(ctx context.Context, fromHeight int32) error {
-	_, err := q.db.Exec(ctx, revertData, fromHeight)
-	return err
-}

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

@@ -1,51 +0,0 @@
-// Code generated by sqlc. DO NOT EDIT.
-// versions:
-//   sqlc v1.26.0
-// source: info.sql
-
-package gen
-
-import (
-	"context"
-)
-
-const getCurrentDBVersion = `-- name: GetCurrentDBVersion :one
-SELECT "version" FROM bitcoin_indexer_db_version ORDER BY id DESC LIMIT 1
-`
-
-func (q *Queries) GetCurrentDBVersion(ctx context.Context) (int32, error) {
-	row := q.db.QueryRow(ctx, getCurrentDBVersion)
-	var version int32
-	err := row.Scan(&version)
-	return version, err
-}
-
-const getCurrentIndexerStats = `-- name: GetCurrentIndexerStats :one
-SELECT "client_version", "network" FROM bitcoin_indexer_stats ORDER BY id DESC LIMIT 1
-`
-
-type GetCurrentIndexerStatsRow struct {
-	ClientVersion string
-	Network       string
-}
-
-func (q *Queries) GetCurrentIndexerStats(ctx context.Context) (GetCurrentIndexerStatsRow, error) {
-	row := q.db.QueryRow(ctx, getCurrentIndexerStats)
-	var i GetCurrentIndexerStatsRow
-	err := row.Scan(&i.ClientVersion, &i.Network)
-	return i, err
-}
-
-const updateIndexerStats = `-- name: UpdateIndexerStats :exec
-INSERT INTO bitcoin_indexer_stats (client_version, network) VALUES ($1, $2)
-`
-
-type UpdateIndexerStatsParams struct {
-	ClientVersion string
-	Network       string
-}
-
-func (q *Queries) UpdateIndexerStats(ctx context.Context, arg UpdateIndexerStatsParams) error {
-	_, err := q.db.Exec(ctx, updateIndexerStats, arg.ClientVersion, arg.Network)
-	return err
-}

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

@@ -1,61 +0,0 @@
-// Code generated by sqlc. DO NOT EDIT.
-// versions:
-//   sqlc v1.26.0
-
-package gen
-
-import (
-	"github.com/jackc/pgx/v5/pgtype"
-)
-
-type BitcoinBlock struct {
-	BlockHeight   int32
-	BlockHash     string
-	Version       int32
-	MerkleRoot    string
-	PrevBlockHash string
-	Timestamp     pgtype.Timestamptz
-	Bits          int64
-	Nonce         int64
-}
-
-type BitcoinIndexerDbVersion struct {
-	Id        int64
-	Version   int32
-	CreatedAt pgtype.Timestamptz
-}
-
-type BitcoinIndexerStat struct {
-	Id            int64
-	ClientVersion string
-	Network       string
-	CreatedAt     pgtype.Timestamptz
-}
-
-type BitcoinTransaction struct {
-	TxHash      string
-	Version     int32
-	Locktime    int64
-	BlockHeight int32
-	BlockHash   string
-	Idx         int32
-}
-
-type BitcoinTransactionTxin struct {
-	TxHash          string
-	TxIdx           int32
-	PrevoutTxHash   string
-	PrevoutTxIdx    int32
-	PrevoutPkscript pgtype.Text
-	Scriptsig       string
-	Witness         string
-	Sequence        int64
-}
-
-type BitcoinTransactionTxout struct {
-	TxHash   string
-	TxIdx    int32
-	Pkscript string
-	Value    int64
-	IsSpent  bool
-}

modules/bitcoin/repository/postgres/info.go

@@ -1,44 +0,0 @@
-package postgres
-
-import (
-	"context"
-
-	"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/bitcoin/datagateway"
-	"github.com/gaze-network/indexer-network/modules/bitcoin/repository/postgres/gen"
-	"github.com/jackc/pgx/v5"
-)
-
-// Make sure Repository implements the IndexerInformationDataGateway interface
-var _ datagateway.IndexerInformationDataGateway = (*Repository)(nil)
-
-func (r *Repository) GetCurrentDBVersion(ctx context.Context) (int32, error) {
-	version, err := r.queries.GetCurrentDBVersion(ctx)
-	if err != nil {
-		return 0, errors.WithStack(err)
-	}
-	return version, nil
-}
-
-func (r *Repository) GetLatestIndexerStats(ctx context.Context) (string, common.Network, error) {
-	stats, err := r.queries.GetCurrentIndexerStats(ctx)
-	if err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return "", "", errors.Join(errs.NotFound, err)
-		}
-		return "", "", errors.WithStack(err)
-	}
-	return stats.ClientVersion, common.Network(stats.Network), nil
-}
-
-func (r *Repository) UpdateIndexerStats(ctx context.Context, clientVersion string, network common.Network) error {
-	if err := r.queries.UpdateIndexerStats(ctx, gen.UpdateIndexerStatsParams{
-		ClientVersion: clientVersion,
-		Network:       network.String(),
-	}); err != nil {
-		return errors.WithStack(err)
-	}
-	return nil
-}

modules/bitcoin/repository/postgres/mappers.go

@@ -1,197 +0,0 @@
-package postgres
-
-import (
-	"cmp"
-	"encoding/hex"
-	"slices"
-
-	"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/types"
-	"github.com/gaze-network/indexer-network/modules/bitcoin/repository/postgres/gen"
-	"github.com/gaze-network/indexer-network/pkg/btcutils"
-	"github.com/jackc/pgx/v5/pgtype"
-)
-
-func mapBlockHeaderModelToType(src gen.BitcoinBlock) (types.BlockHeader, error) {
-	hash, err := chainhash.NewHashFromStr(src.BlockHash)
-	if err != nil {
-		return types.BlockHeader{}, errors.Join(errors.Wrap(err, "failed to parse block hash"), errs.InternalError)
-	}
-	prevHash, err := chainhash.NewHashFromStr(src.PrevBlockHash)
-	if err != nil {
-		return types.BlockHeader{}, errors.Join(errors.Wrap(err, "failed to parse prev block hash"), errs.InternalError)
-	}
-	merkleRoot, err := chainhash.NewHashFromStr(src.MerkleRoot)
-	if err != nil {
-		return types.BlockHeader{}, errors.Join(errors.Wrap(err, "failed to parse merkle root"), errs.InternalError)
-	}
-	return types.BlockHeader{
-		Hash:       *hash,
-		Height:     int64(src.BlockHeight),
-		Version:    src.Version,
-		PrevBlock:  *prevHash,
-		MerkleRoot: *merkleRoot,
-		Timestamp:  src.Timestamp.Time,
-		Bits:       uint32(src.Bits),
-		Nonce:      uint32(src.Nonce),
-	}, nil
-}
-
-func mapBlocksTypeToParams(src []*types.Block) (gen.BatchInsertBlocksParams, gen.BatchInsertTransactionsParams, gen.BatchInsertTransactionTxOutsParams, gen.BatchInsertTransactionTxInsParams) {
-	blocks := gen.BatchInsertBlocksParams{
-		BlockHeightArr:   make([]int32, 0, len(src)),
-		BlockHashArr:     make([]string, 0, len(src)),
-		VersionArr:       make([]int32, 0, len(src)),
-		MerkleRootArr:    make([]string, 0, len(src)),
-		PrevBlockHashArr: make([]string, 0, len(src)),
-		TimestampArr:     make([]pgtype.Timestamptz, 0, len(src)),
-		BitsArr:          make([]int64, 0, len(src)),
-		NonceArr:         make([]int64, 0, len(src)),
-	}
-	txs := gen.BatchInsertTransactionsParams{
-		TxHashArr:      []string{},
-		VersionArr:     []int32{},
-		LocktimeArr:    []int64{},
-		BlockHeightArr: []int32{},
-		BlockHashArr:   []string{},
-		IdxArr:         []int32{},
-	}
-	txouts := gen.BatchInsertTransactionTxOutsParams{
-		TxHashArr:   []string{},
-		TxIdxArr:    []int32{},
-		PkscriptArr: []string{},
-		ValueArr:    []int64{},
-	}
-	txins := gen.BatchInsertTransactionTxInsParams{
-		PrevoutTxHashArr: []string{},
-		PrevoutTxIdxArr:  []int32{},
-		TxHashArr:        []string{},
-		TxIdxArr:         []int32{},
-		ScriptsigArr:     []string{},
-		WitnessArr:       []string{},
-		SequenceArr:      []int32{},
-	}
-
-	for _, block := range src {
-		blockHash := block.Header.Hash.String()
-
-		// Batch insert blocks
-		blocks.BlockHeightArr = append(blocks.BlockHeightArr, int32(block.Header.Height))
-		blocks.BlockHashArr = append(blocks.BlockHashArr, blockHash)
-		blocks.VersionArr = append(blocks.VersionArr, block.Header.Version)
-		blocks.MerkleRootArr = append(blocks.MerkleRootArr, block.Header.MerkleRoot.String())
-		blocks.PrevBlockHashArr = append(blocks.PrevBlockHashArr, block.Header.PrevBlock.String())
-		blocks.TimestampArr = append(blocks.TimestampArr, pgtype.Timestamptz{
-			Time:  block.Header.Timestamp,
-			Valid: true,
-		})
-		blocks.BitsArr = append(blocks.BitsArr, int64(block.Header.Bits))
-		blocks.NonceArr = append(blocks.NonceArr, int64(block.Header.Nonce))
-
-		for txIdx, srcTx := range block.Transactions {
-			txHash := srcTx.TxHash.String()
-
-			// Batch insert transactions
-			txs.TxHashArr = append(txs.TxHashArr, txHash)
-			txs.VersionArr = append(txs.VersionArr, srcTx.Version)
-			txs.LocktimeArr = append(txs.LocktimeArr, int64(srcTx.LockTime))
-			txs.BlockHeightArr = append(txs.BlockHeightArr, int32(block.Header.Height))
-			txs.BlockHashArr = append(txs.BlockHashArr, blockHash)
-			txs.IdxArr = append(txs.IdxArr, int32(txIdx))
-
-			// Batch insert txins
-			for idx, txin := range srcTx.TxIn {
-				var witness string
-				if len(txin.Witness) > 0 {
-					witness = btcutils.WitnessToString(txin.Witness)
-				}
-				txins.TxHashArr = append(txins.TxHashArr, txHash)
-				txins.TxIdxArr = append(txins.TxIdxArr, int32(idx))
-				txins.PrevoutTxHashArr = append(txins.PrevoutTxHashArr, txin.PreviousOutTxHash.String())
-				txins.PrevoutTxIdxArr = append(txins.PrevoutTxIdxArr, int32(txin.PreviousOutIndex))
-				txins.ScriptsigArr = append(txins.ScriptsigArr, hex.EncodeToString(txin.SignatureScript))
-				txins.WitnessArr = append(txins.WitnessArr, witness)
-				txins.SequenceArr = append(txins.SequenceArr, int32(txin.Sequence))
-			}
-
-			// Batch insert txouts
-			for idx, txout := range srcTx.TxOut {
-				txouts.TxHashArr = append(txouts.TxHashArr, txHash)
-				txouts.TxIdxArr = append(txouts.TxIdxArr, int32(idx))
-				txouts.PkscriptArr = append(txouts.PkscriptArr, hex.EncodeToString(txout.PkScript))
-				txouts.ValueArr = append(txouts.ValueArr, txout.Value)
-			}
-		}
-	}
-	return blocks, txs, txouts, txins
-}
-
-func mapTransactionModelToType(src gen.BitcoinTransaction, txInModel []gen.BitcoinTransactionTxin, txOutModels []gen.BitcoinTransactionTxout) (types.Transaction, error) {
-	blockHash, err := chainhash.NewHashFromStr(src.BlockHash)
-	if err != nil {
-		return types.Transaction{}, errors.Wrap(err, "failed to parse block hash")
-	}
-
-	txHash, err := chainhash.NewHashFromStr(src.TxHash)
-	if err != nil {
-		return types.Transaction{}, errors.Wrap(err, "failed to parse tx hash")
-	}
-
-	// Sort txins and txouts by index (Asc)
-	slices.SortFunc(txOutModels, func(i, j gen.BitcoinTransactionTxout) int {
-		return cmp.Compare(i.TxIdx, j.TxIdx)
-	})
-	slices.SortFunc(txInModel, func(i, j gen.BitcoinTransactionTxin) int {
-		return cmp.Compare(i.TxIdx, j.TxIdx)
-	})
-
-	txIns := make([]*types.TxIn, 0, len(txInModel))
-	txOuts := make([]*types.TxOut, 0, len(txOutModels))
-	for _, txInModel := range txInModel {
-		scriptsig, err := hex.DecodeString(txInModel.Scriptsig)
-		if err != nil {
-			return types.Transaction{}, errors.Wrap(err, "failed to decode scriptsig")
-		}
-
-		prevoutTxHash, err := chainhash.NewHashFromStr(txInModel.PrevoutTxHash)
-		if err != nil {
-			return types.Transaction{}, errors.Wrap(err, "failed to parse prevout tx hash")
-		}
-
-		witness, err := btcutils.WitnessFromString(txInModel.Witness)
-		if err != nil {
-			return types.Transaction{}, errors.Wrap(err, "failed to parse witness from hex string")
-		}
-
-		txIns = append(txIns, &types.TxIn{
-			SignatureScript:   scriptsig,
-			Witness:           witness,
-			Sequence:          uint32(txInModel.Sequence),
-			PreviousOutIndex:  uint32(txInModel.PrevoutTxIdx),
-			PreviousOutTxHash: *prevoutTxHash,
-		})
-	}
-	for _, txOutModel := range txOutModels {
-		pkscript, err := hex.DecodeString(txOutModel.Pkscript)
-		if err != nil {
-			return types.Transaction{}, errors.Wrap(err, "failed to decode pkscript")
-		}
-		txOuts = append(txOuts, &types.TxOut{
-			PkScript: pkscript,
-			Value:    txOutModel.Value,
-		})
-	}
-
-	return types.Transaction{
-		BlockHeight: int64(src.BlockHeight),
-		BlockHash:   *blockHash,
-		Index:       uint32(src.Idx),
-		TxHash:      *txHash,
-		Version:     src.Version,
-		LockTime:    uint32(src.Locktime),
-		TxIn:        txIns,
-		TxOut:       txOuts,
-	}, nil
-}

modules/bitcoin/repository/postgres/postgres.go

@@ -1,22 +0,0 @@
-package postgres
-
-import (
-	"github.com/gaze-network/indexer-network/internal/postgres"
-	"github.com/gaze-network/indexer-network/modules/bitcoin/datagateway"
-	"github.com/gaze-network/indexer-network/modules/bitcoin/repository/postgres/gen"
-)
-
-// Make sure Repository implements the BitcoinDataGateway interface
-var _ datagateway.BitcoinDataGateway = (*Repository)(nil)
-
-type Repository struct {
-	db      postgres.DB
-	queries *gen.Queries
-}
-
-func NewRepository(db postgres.DB) *Repository {
-	return &Repository{
-		db:      db,
-		queries: gen.New(db),
-	}
-}

modules/bitcoin/repository/postgres/transaction.go

@@ -1,35 +0,0 @@
-package postgres
-
-import (
-	"context"
-
-	"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/types"
-	"github.com/jackc/pgx/v5"
-)
-
-func (r *Repository) GetTransactionByHash(ctx context.Context, txHash chainhash.Hash) (*types.Transaction, error) {
-	model, err := r.queries.GetTransactionByHash(ctx, txHash.String())
-	if err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return nil, errors.Join(errs.NotFound, err)
-		}
-		return nil, errors.Wrap(err, "failed to get transaction by hash")
-	}
-	txIns, err := r.queries.GetTransactionTxInsByTxHashes(ctx, []string{txHash.String()})
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to get transaction txins by tx hashes")
-	}
-	txOuts, err := r.queries.GetTransactionTxOutsByTxHashes(ctx, []string{txHash.String()})
-	if err != nil && !errors.Is(err, pgx.ErrNoRows) {
-		return nil, errors.Wrap(err, "failed to get transaction txouts by tx hashes")
-	}
-
-	tx, err := mapTransactionModelToType(model, txIns, txOuts)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to map transaction model to type")
-	}
-	return &tx, nil
-}

modules/bitcoin/types.go

@@ -1 +0,0 @@
-package bitcoin

modules/nodesale/api/httphandler/deploy.go

@@ -0,0 +1,99 @@
+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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,72 @@
+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/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")
+	}
+
+	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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,15 @@
+-- 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

@@ -0,0 +1,14 @@
+-- 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

@@ -0,0 +1,51 @@
+-- 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;

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

@@ -0,0 +1,9 @@
+-- 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

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

modules/nodesale/datagateway/nodesale.go

@@ -0,0 +1,76 @@
+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)
+	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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,84 @@
+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

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,139 @@
+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

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,51 @@
+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

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

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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,283 @@
+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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,303 @@
+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

@@ -0,0 +1,806 @@
+// 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

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,87 @@
+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

@@ -0,0 +1,902 @@
+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

@@ -0,0 +1,62 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.26.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/events.sql.go

@@ -0,0 +1,104 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.26.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

@@ -0,0 +1,55 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.26.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

@@ -0,0 +1,271 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.26.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 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

@@ -0,0 +1,92 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.26.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

@@ -0,0 +1,20 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.26.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

@@ -0,0 +1,74 @@
+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

@@ -0,0 +1,236 @@
+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
+}

modules/nodesale/repository/postgres/tx.go

@@ -0,0 +1,62 @@
+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

@@ -0,0 +1,25 @@
+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_holders.go

@@ -72,6 +72,9 @@ func (h *HttpHandler) GetHolders(ctx *fiber.Ctx) (err error) {
 
 	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 GetHoldersByHeight")
 	}
 	holdingBalances, err := h.usecase.GetBalancesByRuneId(ctx.UserContext(), runeId, blockHeight)

modules/runes/api/httphandler/get_token_info.go

@@ -99,6 +99,9 @@ func (h *HttpHandler) GetTokenInfo(ctx *fiber.Ctx) (err error) {
 
 	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 GetTokenInfoByHeight")
 	}
 	holdingBalances, err := h.usecase.GetBalancesByRuneId(ctx.UserContext(), runeId, blockHeight)

modules/runes/api/httphandler/get_transactions.go

@@ -2,6 +2,7 @@ package httphandler
 
 import (
 	"encoding/hex"
+	"fmt"
 	"slices"
 
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
@@ -14,9 +15,11 @@ import (
 )
 
 type getTransactionsRequest struct {
-	Wallet      string `query:"wallet"`
-	Id          string `query:"id"`
-	BlockHeight uint64 `query:"blockHeight"`
+	Wallet string `query:"wallet"`
+	Id     string `query:"id"`
+
+	FromBlock int64 `query:"fromBlock"`
+	ToBlock   int64 `query:"toBlock"`
 }
 
 func (r getTransactionsRequest) Validate() error {
@@ -24,6 +27,12 @@ func (r getTransactionsRequest) Validate() error {
 	if r.Id != "" && !isRuneIdOrRuneName(r.Id) {
 		errList = append(errList, errors.New("'id' is not valid rune id or rune name"))
 	}
+	if r.FromBlock < -1 {
+		errList = append(errList, errors.Errorf("invalid fromBlock range"))
+	}
+	if r.ToBlock < -1 {
+		errList = append(errList, errors.Errorf("invalid toBlock range"))
+	}
 	return errs.WithPublicMessage(errors.Join(errList...), "validation error")
 }
 
@@ -125,17 +134,31 @@ func (h *HttpHandler) GetTransactions(ctx *fiber.Ctx) (err error) {
 		}
 	}
 
-	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{}) {
+	// 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 {
 		blockHeader, err := h.usecase.GetLatestBlock(ctx.UserContext())
 		if err != nil {
 			return errors.Wrap(err, "error during GetLatestBlock")
 		}
-		blockHeight = uint64(blockHeader.Height)
+		if req.FromBlock == -1 {
+			req.FromBlock = blockHeader.Height
+		}
+		if req.ToBlock == -1 {
+			req.ToBlock = blockHeader.Height
+		}
 	}
 
-	txs, err := h.usecase.GetRuneTransactions(ctx.UserContext(), pkScript, runeId, blockHeight)
+	// 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))
 	if err != nil {
 		return errors.Wrap(err, "error during GetRuneTransactions")
 	}

modules/runes/config/config.go

@@ -3,7 +3,7 @@ package config
 import "github.com/gaze-network/indexer-network/internal/postgres"
 
 type Config struct {
-	Datasource  string          `mapstructure:"datasource"`   // Datasource to fetch bitcoin data for Meta-Protocol e.g. `bitcoin-node` | `database`
+	Datasource  string          `mapstructure:"datasource"`   // Datasource to fetch bitcoin data for Meta-Protocol e.g. `bitcoin-node`
 	Database    string          `mapstructure:"database"`     // Database to store runes data.
 	APIHandlers []string        `mapstructure:"api_handlers"` // List of API handlers to enable. (e.g. `http`)
 	Postgres    postgres.Config `mapstructure:"postgres"`

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

@@ -55,8 +55,9 @@ 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 (
-    @block_height::INT = 0 OR runes_transactions.block_height = @block_height::INT -- if @block_height > 0, apply block_height filter
-  );
+    @from_block <= runes_transactions.block_height AND runes_transactions.block_height <= @to_block
+  )
+ORDER BY runes_transactions.block_height DESC LIMIT 10000;
 
 -- name: CountRuneEntries :one
 SELECT COUNT(*) FROM runes_entries;

modules/runes/datagateway/runes.go

@@ -27,7 +27,7 @@ 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, height uint64) ([]*entity.RuneTransaction, error)
+	GetRuneTransactions(ctx context.Context, pkScript []byte, runeId runes.RuneId, fromBlock, toBlock uint64) ([]*entity.RuneTransaction, error)
 
 	GetRunesBalancesAtOutPoint(ctx context.Context, outPoint wire.OutPoint) (map[runes.RuneId]*entity.OutPointBalance, error)
 	GetUnspentOutPointBalancesByPkScript(ctx context.Context, pkScript []byte, blockHeight uint64) ([]*entity.OutPointBalance, error)

modules/runes/processor.go

@@ -9,12 +9,12 @@ import (
 	"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/indexers"
+	"github.com/gaze-network/indexer-network/core/indexer"
 	"github.com/gaze-network/indexer-network/core/types"
-	"github.com/gaze-network/indexer-network/modules/bitcoin/btcclient"
 	"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/btcclient"
 	"github.com/gaze-network/indexer-network/pkg/logger"
 	"github.com/gaze-network/indexer-network/pkg/logger/slogx"
 	"github.com/gaze-network/indexer-network/pkg/reportingclient"
@@ -22,15 +22,16 @@ import (
 	"github.com/samber/lo"
 )
 
-var _ indexers.BitcoinProcessor = (*Processor)(nil)
+// Make sure to implement the Bitcoin Processor interface
+var _ indexer.Processor[*types.Block] = (*Processor)(nil)
 
 type Processor struct {
-	runesDg           datagateway.RunesDataGateway
-	indexerInfoDg     datagateway.IndexerInfoDataGateway
-	bitcoinClient     btcclient.Contract
-	bitcoinDataSource indexers.BitcoinDatasource
-	network           common.Network
-	reportingClient   *reportingclient.ReportingClient
+	runesDg         datagateway.RunesDataGateway
+	indexerInfoDg   datagateway.IndexerInfoDataGateway
+	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 +41,14 @@ type Processor struct {
 	newRuneTxs          []*entity.RuneTransaction
 }
 
-func NewProcessor(runesDg datagateway.RunesDataGateway, indexerInfoDg datagateway.IndexerInfoDataGateway, bitcoinClient btcclient.Contract, bitcoinDataSource indexers.BitcoinDatasource, network common.Network, reportingClient *reportingclient.ReportingClient) *Processor {
+func NewProcessor(runesDg datagateway.RunesDataGateway, indexerInfoDg datagateway.IndexerInfoDataGateway, bitcoinClient btcclient.Contract, network common.Network, reportingClient *reportingclient.ReportingClient, cleanupFuncs []func(context.Context) error) *Processor {
 	return &Processor{
 		runesDg:             runesDg,
 		indexerInfoDg:       indexerInfoDg,
 		bitcoinClient:       bitcoinClient,
-		bitcoinDataSource:   bitcoinDataSource,
 		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),
@@ -229,3 +230,13 @@ 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

@@ -146,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)
 						}
 					}
@@ -466,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, err := p.bitcoinClient.GetTransactionByHash(ctx, txIn.PreviousOutTxHash)
+			prevTx, blockHeight, err := p.bitcoinClient.GetRawTransactionAndHeightByTxHash(ctx, txIn.PreviousOutTxHash)
 			if err != nil && errors.Is(err, errs.NotFound) {
 				continue
 			}
@@ -479,7 +479,7 @@ func (p *Processor) txCommitsToRune(ctx context.Context, tx *types.Transaction,
 				break
 			}
 			// input must be mature enough
-			confirmations := tx.BlockHeight - prevTx.BlockHeight + 1
+			confirmations := tx.BlockHeight - blockHeight + 1
 			if confirmations < runes.RUNE_COMMIT_BLOCKS {
 				continue
 			}

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

@@ -646,8 +646,9 @@ SELECT hash, runes_transactions.block_height, index, timestamp, inputs, outputs,
     OR runes_transactions.burns ? $5
     OR (runes_transactions.rune_etched = TRUE AND runes_transactions.block_height = $6 AND runes_transactions.index = $7)
   ) AND (
-    $8::INT = 0 OR runes_transactions.block_height = $8::INT -- if @block_height > 0, apply block_height filter
+    $8 <= runes_transactions.block_height AND runes_transactions.block_height <= $9
   )
+ORDER BY runes_transactions.block_height DESC LIMIT 10000
 `
 
 type GetRuneTransactionsParams struct {
@@ -658,7 +659,8 @@ type GetRuneTransactionsParams struct {
 	RuneID            []byte
 	RuneIDBlockHeight int32
 	RuneIDTxIndex     int32
-	BlockHeight       int32
+	FromBlock         int32
+	ToBlock           int32
 }
 
 type GetRuneTransactionsRow struct {
@@ -703,7 +705,8 @@ func (q *Queries) GetRuneTransactions(ctx context.Context, arg GetRuneTransactio
 		arg.RuneID,
 		arg.RuneIDBlockHeight,
 		arg.RuneIDTxIndex,
-		arg.BlockHeight,
+		arg.FromBlock,
+		arg.ToBlock,
 	)
 	if err != nil {
 		return nil, err

modules/runes/repository/postgres/runes.go

@@ -62,7 +62,7 @@ func (r *Repository) GetIndexedBlockByHeight(ctx context.Context, height int64)
 	return indexedBlock, nil
 }
 
-func (r *Repository) GetRuneTransactions(ctx context.Context, pkScript []byte, runeId runes.RuneId, height uint64) ([]*entity.RuneTransaction, error) {
+func (r *Repository) GetRuneTransactions(ctx context.Context, pkScript []byte, runeId runes.RuneId, fromBlock, toBlock uint64) ([]*entity.RuneTransaction, error) {
 	pkScriptParam := []byte(fmt.Sprintf(`[{"pkScript":"%s"}]`, hex.EncodeToString(pkScript)))
 	runeIdParam := []byte(fmt.Sprintf(`[{"runeId":"%s"}]`, runeId.String()))
 	rows, err := r.queries.GetRuneTransactions(ctx, gen.GetRuneTransactionsParams{
@@ -75,7 +75,8 @@ func (r *Repository) GetRuneTransactions(ctx context.Context, pkScript []byte, r
 		RuneIDBlockHeight: int32(runeId.BlockHeight),
 		RuneIDTxIndex:     int32(runeId.TxIndex),
 
-		BlockHeight: int32(height),
+		FromBlock: int32(fromBlock),
+		ToBlock:   int32(toBlock),
 	})
 	if err != nil {
 		return nil, errors.Wrap(err, "error during query")

modules/runes/repository/postgres/tx.go

@@ -6,7 +6,7 @@ import (
 	"github.com/cockroachdb/errors"
 	"github.com/gaze-network/indexer-network/modules/runes/datagateway"
 	"github.com/gaze-network/indexer-network/pkg/logger"
-	"github.com/jackc/pgx"
+	"github.com/jackc/pgx/v5"
 )
 
 var ErrTxAlreadyExists = errors.New("Transaction already exists. Call Commit() or Rollback() first.")