feat: recover nodesale module.

2026-01-12 16:53:08 +08:00 · 2024-07-10 16:47:28 +07:00
parent 880f4b2e6a
commit 338d4d47b3
41 changed files with 3907 additions and 5 deletions
--- a/cmd/cmd_run.go
+++ b/cmd/cmd_run.go
@@ -17,6 +17,7 @@ import (
 	"github.com/gaze-network/indexer-network/common/errs"
 	"github.com/gaze-network/indexer-network/core/indexer"
 	"github.com/gaze-network/indexer-network/internal/config"
+	"github.com/gaze-network/indexer-network/modules/nodesale"
 	"github.com/gaze-network/indexer-network/modules/runes"
 	"github.com/gaze-network/indexer-network/pkg/automaxprocs"
 	"github.com/gaze-network/indexer-network/pkg/logger"
@@ -39,6 +40,7 @@ import (
 // Register Modules
 var Modules = do.Package(
 	do.LazyNamed("runes", runes.New),
+	do.LazyNamed("nodesale", nodesale.New),
 )

 func NewRunCommand() *cobra.Command {
--- a/cmd/cmd_version.go
+++ b/cmd/cmd_version.go
@@ -6,13 +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/nodesale"
 	"github.com/gaze-network/indexer-network/modules/runes"
 	"github.com/spf13/cobra"
 )

 var versions = map[string]string{
-	"":      constants.Version,
-	"runes": runes.Version,
+	"":         constants.Version,
+	"runes":    runes.Version,
+	"nodesale": nodesale.Version,
 }

 type versionCmdOptions struct {
--- a/config.example.yaml
+++ b/config.example.yaml
@@ -47,3 +47,10 @@ 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"
--- a/go.mod
+++ b/go.mod
@@ -25,12 +25,13 @@ require (
 	github.com/valyala/fasthttp v1.51.0
 	go.uber.org/automaxprocs v1.5.3
 	golang.org/x/sync v0.7.0
+	google.golang.org/protobuf v1.33.0
 )

 require (
 	github.com/andybalholm/brotli v1.0.5 // indirect
 	github.com/bitonicnl/verify-signed-message v0.7.1
-	github.com/btcsuite/btcd/btcec/v2 v2.3.3 // indirect
+	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
@@ -38,7 +39,7 @@ require (
 	github.com/cockroachdb/redact v1.1.5 // indirect
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
 	github.com/decred/dcrd/crypto/blake256 v1.0.1 // indirect
-	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0 // 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
--- a/go.sum
+++ b/go.sum
@@ -310,6 +310,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=
--- a/internal/config/config.go
+++ b/internal/config/config.go
@@ -8,6 +8,7 @@ import (

 	"github.com/cockroachdb/errors"
 	"github.com/gaze-network/indexer-network/common"
+	nodesaleconfig "github.com/gaze-network/indexer-network/modules/nodesale/config"
 	runesconfig "github.com/gaze-network/indexer-network/modules/runes/config"
 	"github.com/gaze-network/indexer-network/pkg/logger"
 	"github.com/gaze-network/indexer-network/pkg/logger/slogx"
@@ -61,7 +62,8 @@ type BitcoinNodeClient struct {
 }

 type Modules struct {
-	Runes runesconfig.Config `mapstructure:"runes"`
+	Runes    runesconfig.Config    `mapstructure:"runes"`
+	Nodesale nodesaleconfig.Config `mapstructure:"nodesale"`
 }

 type HTTPServerConfig struct {
--- a/modules/nodesale/api/httphandler/handlers.go
+++ b/modules/nodesale/api/httphandler/handlers.go
@@ -0,0 +1,196 @@
+package httphandler
+
+import (
+	"fmt"
+
+	"github.com/gaze-network/indexer-network/modules/nodesale/protobuf"
+	repository "github.com/gaze-network/indexer-network/modules/nodesale/repository/postgres"
+	"github.com/gaze-network/indexer-network/modules/nodesale/repository/postgres/gen"
+	"github.com/gofiber/fiber/v2"
+	"google.golang.org/protobuf/encoding/protojson"
+)
+
+type handler struct {
+	repository *repository.Repository
+}
+
+func New(repo *repository.Repository) *handler {
+	h := handler{}
+	h.repository = repo
+	return &h
+}
+
+func (h *handler) infoHandler(ctx *fiber.Ctx) error {
+	block, err := h.repository.Queries.GetLastProcessedBlock(ctx.UserContext())
+	if err != nil {
+		return fmt.Errorf("Cannot get last processed block : %w", err)
+	}
+	err = ctx.JSON(infoResponse{
+		IndexedBlockHeight: block.BlockHeight,
+		IndexedBlockHash:   block.BlockHash,
+	})
+	if err != nil {
+		return fmt.Errorf("Go fiber cannot parse JSON: %w", err)
+	}
+	return nil
+}
+
+func (h *handler) deployHandler(ctx *fiber.Ctx) error {
+	deployId := ctx.Params("deployId")
+	if deployId == "" {
+		err := ctx.SendStatus(404)
+		if err != nil {
+			return fmt.Errorf("Go fiber cannot send status: %w", err)
+		}
+		return nil
+	}
+	var blockHeight, txIndex int32
+	count, err := fmt.Sscanf(deployId, "%d-%d", &blockHeight, &txIndex)
+	if count != 2 || err != nil {
+		err := ctx.SendStatus(404)
+		if err != nil {
+			return fmt.Errorf("Go fiber cannot send status: %w", err)
+		}
+		return nil
+	}
+	deploys, err := h.repository.Queries.GetNodesale(ctx.UserContext(), gen.GetNodesaleParams{
+		BlockHeight: blockHeight,
+		TxIndex:     txIndex,
+	})
+	if err != nil {
+		return fmt.Errorf("Cannot get nodesale from db: %w", err)
+	}
+	if len(deploys) < 1 {
+		err := ctx.SendStatus(404)
+		if err != nil {
+			return fmt.Errorf("Go fiber cannot send status: %w", err)
+		}
+		return nil
+	}
+
+	deploy := deploys[0]
+
+	nodeCount, err := h.repository.Queries.GetNodeCountByTierIndex(ctx.UserContext(), gen.GetNodeCountByTierIndexParams{
+		SaleBlock:   deploy.BlockHeight,
+		SaleTxIndex: deploy.TxIndex,
+		FromTier:    0,
+		ToTier:      int32(len(deploy.Tiers) - 1),
+	})
+	if err != nil {
+		return fmt.Errorf("Cannot get node count from db : %w", err)
+	}
+
+	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 fmt.Errorf("Failed to decode tiers json : %w", err)
+		}
+		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:              deployId,
+		Name:            deploy.Name,
+		StartAt:         deploy.StartsAt.Time.UTC(),
+		EndAt:           deploy.EndsAt.Time.UTC(),
+		Tiers:           tierResponses,
+		SellerPublicKey: deploy.SellerPublicKey,
+		MaxPerAddress:   deploy.MaxPerAddress,
+		DeployTxHash:    deploy.DeployTxHash,
+	})
+	if err != nil {
+		return fmt.Errorf("Go fiber cannot parse JSON: %w", err)
+	}
+	return nil
+}
+
+func (h *handler) nodesHandler(ctx *fiber.Ctx) error {
+	deployId := ctx.Query("deployId")
+	if deployId == "" {
+		err := ctx.SendStatus(404)
+		if err != nil {
+			return fmt.Errorf("Go fiber cannot send status: %w", err)
+		}
+		return nil
+	}
+	ownerPublicKey := ctx.Query("ownerPublicKey")
+	delegateePublicKey := ctx.Query("delegateePublicKey")
+
+	var blockHeight, txIndex int32
+	count, err := fmt.Sscanf(deployId, "%d-%d", &blockHeight, &txIndex)
+	if count != 2 || err != nil {
+		err := ctx.SendStatus(404)
+		if err != nil {
+			return fmt.Errorf("Go fiber cannot send status: %w", err)
+		}
+		return nil
+	}
+
+	nodes, err := h.repository.Queries.GetNodesByPubkey(ctx.UserContext(), gen.GetNodesByPubkeyParams{
+		SaleBlock:      blockHeight,
+		SaleTxIndex:    txIndex,
+		OwnerPublicKey: ownerPublicKey,
+		DelegatedTo:    delegateePublicKey,
+	})
+	if err != nil {
+		err := ctx.SendStatus(404)
+		if err != nil {
+			return fmt.Errorf("Can't get nodes from db: %w", err)
+		}
+		return nil
+	}
+	responses := make([]nodeResponse, len(nodes))
+	for i, node := range nodes {
+		responses[i].DeployId = 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 = node.TxIndex
+	}
+
+	err = ctx.JSON(responses)
+	if err != nil {
+		return fmt.Errorf("Go fiber cannot parse JSON: %w", err)
+	}
+	return nil
+}
+
+func (h *handler) eventsHandler(ctx *fiber.Ctx) error {
+	walletAddress := ctx.Query("walletAddress")
+
+	events, err := h.repository.Queries.GetEventsByWallet(ctx.UserContext(), walletAddress)
+	if err != nil {
+		err := ctx.SendStatus(404)
+		if err != nil {
+			return fmt.Errorf("Can't get events from db: %w", err)
+		}
+		return nil
+	}
+
+	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.Time.UTC()
+		responses[i].BlockHash = event.BlockHash
+	}
+
+	err = ctx.JSON(responses)
+	if err != nil {
+		return fmt.Errorf("Go fiber cannot parse JSON: %w", err)
+	}
+	return nil
+}
--- a/modules/nodesale/api/httphandler/responses.go
+++ b/modules/nodesale/api/httphandler/responses.go
@@ -0,0 +1,51 @@
+package httphandler
+
+import (
+	"encoding/json"
+	"time"
+)
+
+type infoResponse struct {
+	IndexedBlockHeight int32  `json:"indexedBlockHeight"`
+	IndexedBlockHash   string `json:"indexedBlockHash"`
+}
+
+type deployResponse struct {
+	Id              string         `json:"id"`
+	Name            string         `json:"name"`
+	StartAt         time.Time      `json:"startAt"`
+	EndAt           time.Time      `json:"EndAt"`
+	Tiers           []tierResponse `json:"tiers"`
+	SellerPublicKey string         `json:"sellerPublicKey"`
+	MaxPerAddress   int32          `json:"maxPerAddress"`
+	DeployTxHash    string         `json:"deployTxHash"`
+}
+
+type tierResponse struct {
+	PriceSat      uint32 `json:"priceSat"`
+	Limit         uint32 `json:"limit"`
+	MaxPerAddress uint32 `json:"maxPerAddress"`
+	Sold          int64  `json:"sold"`
+}
+
+type nodeResponse struct {
+	DeployId            string `json:"deployId"`
+	NodeId              int32  `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"`
+}
+
+type eventResposne struct {
+	TxHash         string          `json:"txHash"`
+	BlockHeight    int32           `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"`
+}
--- a/modules/nodesale/api/httphandler/routes.go
+++ b/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
+}
--- a/modules/nodesale/config/config.go
+++ b/modules/nodesale/config/config.go
@@ -0,0 +1,7 @@
+package config
+
+import "github.com/gaze-network/indexer-network/internal/postgres"
+
+type Config struct {
+	Postgres postgres.Config `mapstructure:"postgres"`
+}
--- a/modules/nodesale/database/postgresql/migrations/000001_initialize.down.sql
+++ b/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;
--- a/modules/nodesale/database/postgresql/migrations/000001_initialize.up.sql
+++ b/modules/nodesale/database/postgresql/migrations/000001_initialize.up.sql
@@ -0,0 +1,63 @@
+BEGIN;
+
+CREATE TABLE IF NOT EXISTS blocks (
+    "block_height" INTEGER 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" INTEGER 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,
+    "block_timestamp" TIMESTAMP NOT NULL,
+    "block_hash" TEXT NOT NULL,
+    "metadata" JSONB NOT NULL
+);
+
+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" INTEGER 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" INTEGER 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;
--- a/modules/nodesale/database/postgresql/queries/blocks.sql
+++ b/modules/nodesale/database/postgresql/queries/blocks.sql
@@ -0,0 +1,16 @@
+-- name: GetLastProcessedBlock :one
+SELECT * FROM blocks
+WHERE "block_height" = (SELECT MAX("block_height") FROM blocks);
+
+
+-- name: GetBlock :one
+SELECT * FROM blocks
+WHERE "block_height" = $1;
+
+-- name: RemoveBlockFrom :execrows
+DELETE FROM blocks
+WHERE "block_height" >= @from_block;
+
+-- name: AddBlock :exec
+INSERT INTO blocks("block_height", "block_hash", "module")
+VALUES ($1, $2, $3);
--- a/modules/nodesale/database/postgresql/queries/events.sql
+++ b/modules/nodesale/database/postgresql/queries/events.sql
@@ -0,0 +1,13 @@
+-- name: RemoveEventsFromBlock :execrows
+DELETE FROM events
+WHERE "block_height" >= @from_block;
+
+-- name: AddEvent :exec
+INSERT INTO events("tx_hash", "block_height", "tx_index", "wallet_address", "valid", "action", 
+                    "raw_message", "parsed_message", "block_timestamp", "block_hash", "metadata")
+VALUES ( $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11);
+
+-- name: GetEventsByWallet :many
+SELECT *
+FROM events
+WHERE wallet_address = $1;
--- a/modules/nodesale/database/postgresql/queries/nodes.sql
+++ b/modules/nodesale/database/postgresql/queries/nodes.sql
@@ -0,0 +1,51 @@
+-- name: ClearDelegate :execrows
+UPDATE nodes
+SET "delegated_to" = ''
+WHERE "delegate_tx_hash" = NULL;
+
+-- name: SetDelegates :execrows
+UPDATE nodes
+SET delegated_to = @delegatee
+WHERE sale_block = $1 AND
+    sale_tx_index = $2 AND
+    node_id = ANY (@node_ids::int[]);
+
+-- name: GetNodes :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 *
+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: AddNode :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 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;
--- a/modules/nodesale/database/postgresql/queries/nodesales.sql
+++ b/modules/nodesale/database/postgresql/queries/nodesales.sql
@@ -0,0 +1,9 @@
+-- name: AddNodesale :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;
--- a/modules/nodesale/database/postgresql/queries/test.sql
+++ b/modules/nodesale/database/postgresql/queries/test.sql
@@ -0,0 +1,4 @@
+-- name: ClearEvents :exec
+DELETE FROM events
+WHERE tx_hash <> '';
+;
--- a/modules/nodesale/delegate.go
+++ b/modules/nodesale/delegate.go
@@ -0,0 +1,83 @@
+package nodesale
+
+import (
+	"context"
+	"encoding/hex"
+	"fmt"
+
+	"github.com/btcsuite/btcd/btcec/v2"
+	"github.com/gaze-network/indexer-network/core/types"
+	"github.com/gaze-network/indexer-network/modules/nodesale/repository/postgres/gen"
+	"github.com/jackc/pgx/v5/pgtype"
+)
+
+func (p *Processor) processDelegate(ctx context.Context, qtx gen.Querier, block *types.Block, event nodesaleEvent) error {
+	valid := true
+	delegate := event.eventMessage.Delegate
+	nodeIds := make([]int32, len(delegate.NodeIDs))
+	for i, id := range delegate.NodeIDs {
+		nodeIds[i] = int32(id)
+	}
+	nodes, err := qtx.GetNodes(ctx, gen.GetNodesParams{
+		SaleBlock:   int32(delegate.DeployID.Block),
+		SaleTxIndex: int32(delegate.DeployID.TxIndex),
+		NodeIds:     nodeIds,
+	})
+	if err != nil {
+		return fmt.Errorf("Failed to get nodes : %w", err)
+	}
+
+	if len(nodeIds) != len(nodes) {
+		valid = false
+	}
+
+	if valid {
+		for _, node := range nodes {
+			OwnerPublicKeyBytes, err := hex.DecodeString(node.OwnerPublicKey)
+			if err != nil {
+				valid = false
+				break
+			}
+			OwnerPublicKey, err := btcec.ParsePubKey(OwnerPublicKeyBytes)
+			if err != nil {
+				valid = false
+				break
+			}
+			if !event.txPubkey.IsEqual(OwnerPublicKey) {
+				valid = false
+				break
+			}
+		}
+	}
+
+	err = qtx.AddEvent(ctx, gen.AddEventParams{
+		TxHash:         event.transaction.TxHash.String(),
+		TxIndex:        int32(event.transaction.Index),
+		Action:         int32(event.eventMessage.Action),
+		RawMessage:     event.rawData,
+		ParsedMessage:  event.eventJson,
+		BlockTimestamp: pgtype.Timestamp{Time: block.Header.Timestamp, Valid: true},
+		BlockHash:      event.transaction.BlockHash.String(),
+		BlockHeight:    int32(event.transaction.BlockHeight),
+		Valid:          valid,
+		// WalletAddress:  event.txAddress.EncodeAddress(),
+		WalletAddress: p.pubkeyToPkHashAddress(event.txPubkey).EncodeAddress(),
+		Metadata:      []byte("{}"),
+	})
+	if err != nil {
+		return fmt.Errorf("Failed to insert event : %w", err)
+	}
+	if valid {
+		_, err = qtx.SetDelegates(ctx, gen.SetDelegatesParams{
+			SaleBlock:   int32(delegate.DeployID.Block),
+			SaleTxIndex: int32(delegate.DeployID.TxIndex),
+			Delegatee:   delegate.DelegateePublicKey,
+			NodeIds:     nodeIds,
+		})
+		if err != nil {
+			return fmt.Errorf("Failed to set delegate : %w", err)
+		}
+	}
+
+	return nil
+}
--- a/modules/nodesale/delegate_test.go
+++ b/modules/nodesale/delegate_test.go
@@ -0,0 +1,131 @@
+package nodesale
+
+import (
+	"encoding/hex"
+	"testing"
+	"time"
+
+	"github.com/btcsuite/btcd/btcec/v2"
+	"github.com/btcsuite/btcd/btcutil"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/txscript"
+	"github.com/decred/dcrd/dcrec/secp256k1/v4/ecdsa"
+	"github.com/gaze-network/indexer-network/core/types"
+	"github.com/gaze-network/indexer-network/modules/nodesale/protobuf"
+	"github.com/gaze-network/indexer-network/modules/nodesale/repository/postgres/gen"
+	"github.com/stretchr/testify/require"
+	"google.golang.org/protobuf/proto"
+)
+
+func TestDelegate(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping test in short mode.")
+	}
+	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)
+	deployMessage := &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:         4,
+					MaxPerAddress: 2,
+				},
+				{
+					PriceSat:      400,
+					Limit:         50,
+					MaxPerAddress: 3,
+				},
+			},
+			SellerPublicKey:       sellerPubkeyHex,
+			MaxPerAddress:         100,
+			MaxDiscountPercentage: 50,
+			SellerWallet:          sellerWallet.EncodeAddress(),
+		},
+	}
+	event, block := assembleTestEvent(sellerPrivateKey, "111111", "111111", 0, 0, deployMessage)
+	p.processDeploy(ctx, qtx, block, event)
+
+	buyerPrivateKey, _ := btcec.NewPrivateKey()
+	buyerPubkeyHex := hex.EncodeToString(buyerPrivateKey.PubKey().SerializeCompressed())
+
+	payload := &protobuf.PurchasePayload{
+		DeployID: &protobuf.ActionID{
+			Block:   uint64(testBlockHeigh) - 1,
+			TxIndex: uint32(testTxIndex) - 1,
+		},
+		BuyerPublicKey: buyerPubkeyHex,
+		TimeOutBlock:   uint64(testBlockHeigh) + 5,
+		NodeIDs:        []uint32{9, 10, 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, "1212121212", "1212121212", 0, 0, message)
+
+	addr, _ := btcutil.NewAddressPubKey(sellerPrivateKey.PubKey().SerializeCompressed(), p.network.ChainParams())
+	pkscript, _ := txscript.PayToAddrScript(addr.AddressPubKeyHash())
+	event.transaction.TxOut = []*types.TxOut{
+		{
+			PkScript: pkscript,
+			Value:    600,
+		},
+	}
+	p.processPurchase(ctx, qtx, block, event)
+
+	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(testBlockHeigh) - 2,
+				TxIndex: uint32(testTxIndex) - 2,
+			},
+		},
+	}
+	event, block = assembleTestEvent(buyerPrivateKey, "131313131313", "131313131313", 0, 0, delegateMessage)
+	p.processDelegate(ctx, qtx, block, event)
+
+	nodes, _ := qtx.GetNodes(ctx, gen.GetNodesParams{
+		SaleBlock:   int32(testBlockHeigh) - 3,
+		SaleTxIndex: int32(testTxIndex) - 3,
+		NodeIds:     []int32{9, 10, 11},
+	})
+	require.Len(t, nodes, 3)
+	for _, node := range nodes {
+		if node.NodeID == 9 || node.NodeID == 10 {
+			require.NotEmpty(t, node.DelegatedTo)
+		} else if node.NodeID == 11 {
+			require.Empty(t, node.DelegatedTo)
+		} else {
+			require.Fail(t, "Unhandled")
+		}
+	}
+}
--- a/modules/nodesale/deploy.go
+++ b/modules/nodesale/deploy.go
@@ -0,0 +1,86 @@
+package nodesale
+
+import (
+	"context"
+	"encoding/hex"
+	"fmt"
+	"time"
+
+	"github.com/btcsuite/btcd/btcec/v2"
+	"github.com/gaze-network/indexer-network/core/types"
+	"github.com/gaze-network/indexer-network/modules/nodesale/repository/postgres/gen"
+	"github.com/jackc/pgx/v5/pgtype"
+	"google.golang.org/protobuf/encoding/protojson"
+)
+
+func (p *Processor) processDeploy(ctx context.Context, qtx gen.Querier, block *types.Block, event nodesaleEvent) error {
+	valid := true
+	deploy := event.eventMessage.Deploy
+
+	sellerPubKeyBytes, err := hex.DecodeString(deploy.SellerPublicKey)
+	if err != nil {
+		valid = false
+	}
+
+	if valid {
+		sellerPubKey, err := btcec.ParsePubKey(sellerPubKeyBytes)
+		if err != nil {
+			valid = false
+		}
+		if valid && !event.txPubkey.IsEqual(sellerPubKey) {
+			valid = false
+		}
+	}
+
+	tiers := make([][]byte, len(deploy.Tiers))
+	for i, tier := range deploy.Tiers {
+		tierJson, err := protojson.Marshal(tier)
+		if err != nil {
+			return fmt.Errorf("Failed to parse tiers to json : %w", err)
+		}
+		tiers[i] = tierJson
+	}
+
+	err = qtx.AddEvent(ctx, gen.AddEventParams{
+		TxHash:         event.transaction.TxHash.String(),
+		TxIndex:        int32(event.transaction.Index),
+		Action:         int32(event.eventMessage.Action),
+		RawMessage:     event.rawData,
+		ParsedMessage:  event.eventJson,
+		BlockTimestamp: pgtype.Timestamp{Time: block.Header.Timestamp, Valid: true},
+		BlockHash:      event.transaction.BlockHash.String(),
+		BlockHeight:    int32(event.transaction.BlockHeight),
+		Valid:          valid,
+		WalletAddress:  p.pubkeyToPkHashAddress(event.txPubkey).EncodeAddress(),
+		Metadata:       []byte("{}"),
+	})
+	if err != nil {
+		return fmt.Errorf("Failed to insert event : %w", err)
+	}
+	if valid {
+		err = qtx.AddNodesale(ctx, gen.AddNodesaleParams{
+			BlockHeight: int32(event.transaction.BlockHeight),
+			TxIndex:     int32(event.transaction.Index),
+			Name:        deploy.Name,
+			StartsAt: pgtype.Timestamp{
+				Time:  time.Unix(int64(deploy.StartsAt), 0).UTC(),
+				Valid: true,
+			},
+			EndsAt: pgtype.Timestamp{
+				Time:  time.Unix(int64(deploy.EndsAt), 0).UTC(),
+				Valid: true,
+			},
+			Tiers:                 tiers,
+			SellerPublicKey:       deploy.SellerPublicKey,
+			MaxPerAddress:         int32(deploy.MaxPerAddress),
+			DeployTxHash:          event.transaction.TxHash.String(),
+			MaxDiscountPercentage: int32(deploy.MaxDiscountPercentage),
+			SellerWallet:          deploy.SellerWallet,
+		})
+		if err != nil {
+			return fmt.Errorf("Failed to insert nodesale : %w", err)
+		}
+	}
+
+	return nil
+}
--- a/modules/nodesale/deploy_test.go
+++ b/modules/nodesale/deploy_test.go
@@ -0,0 +1,94 @@
+package nodesale
+
+import (
+	"encoding/hex"
+	"testing"
+
+	"github.com/btcsuite/btcd/btcec/v2"
+	"github.com/gaze-network/indexer-network/modules/nodesale/protobuf"
+	"github.com/gaze-network/indexer-network/modules/nodesale/repository/postgres/gen"
+	"github.com/stretchr/testify/require"
+)
+
+func TestDeployInvalid(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping test in short mode.")
+	}
+	prvKey, _ := btcec.NewPrivateKey()
+	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:       "0102030405",
+			MaxPerAddress:         100,
+			MaxDiscountPercentage: 50,
+			SellerWallet:          sellerWallet.EncodeAddress(),
+		},
+	}
+
+	event, block := assembleTestEvent(prvKey, "0101010101", "0101010101", 0, 0, message)
+	p.processDeploy(ctx, qtx, block, event)
+
+	nodesales, _ := qtx.GetNodesale(ctx, gen.GetNodesaleParams{
+		BlockHeight: int32(testBlockHeigh) - 1,
+		TxIndex:     int32(testTxIndex) - 1,
+	})
+	require.Len(t, nodesales, 0)
+}
+
+func TestDeployValid(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping test in short mode.")
+	}
+	privateKey, _ := btcec.NewPrivateKey()
+	pubkeyHex := hex.EncodeToString(privateKey.PubKey().SerializeCompressed())
+	sellerWallet := p.pubkeyToPkHashAddress(privateKey.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:       pubkeyHex,
+			MaxPerAddress:         100,
+			MaxDiscountPercentage: 50,
+			SellerWallet:          sellerWallet.EncodeAddress(),
+		},
+	}
+
+	event, block := assembleTestEvent(privateKey, "0202020202", "0202020202", 0, 0, message)
+	p.processDeploy(ctx, qtx, block, event)
+
+	nodesales, _ := qtx.GetNodesale(ctx, gen.GetNodesaleParams{
+		BlockHeight: int32(testBlockHeigh) - 1,
+		TxIndex:     int32(testTxIndex) - 1,
+	})
+	require.Len(t, nodesales, 1)
+}
--- a/modules/nodesale/nodesale.go
+++ b/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 (
+	NODESALE_LASTBLOCK_DEFAULT = 846851
+	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{
+		repository:   repository,
+		btcClient:    datasource,
+		network:      conf.Network,
+		cleanupFuncs: cleanupFuncs,
+	}
+
+	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
+}
--- a/modules/nodesale/nodesale_test.go
+++ b/modules/nodesale/nodesale_test.go
@@ -0,0 +1,110 @@
+package nodesale
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+	"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/common"
+	"github.com/gaze-network/indexer-network/core/types"
+	"github.com/gaze-network/indexer-network/internal/postgres"
+	"github.com/gaze-network/indexer-network/modules/nodesale/protobuf"
+	repository "github.com/gaze-network/indexer-network/modules/nodesale/repository/postgres"
+	"github.com/gaze-network/indexer-network/modules/nodesale/repository/postgres/gen"
+	"github.com/jackc/pgx/v5"
+	"google.golang.org/protobuf/encoding/protojson"
+	"google.golang.org/protobuf/proto"
+)
+
+var p *Processor
+
+var postgresConf postgres.Config = postgres.Config{
+	User:     "postgres",
+	Password: "P@ssw0rd",
+}
+
+var qtx gen.Querier
+
+var ctx context.Context
+
+var tx pgx.Tx
+
+var (
+	testBlockHeigh int = 101
+	testTxIndex    int = 1
+)
+
+func TestMain(m *testing.M) {
+	flag.Parse()
+	if testing.Short() {
+		return
+	}
+
+	ctx = context.Background()
+
+	db, _ := postgres.NewPool(ctx, postgresConf)
+
+	repo := repository.NewRepository(db)
+
+	p = &Processor{
+		repository: repo,
+		network:    common.NetworkMainnet,
+	}
+	repo.Queries.ClearEvents(ctx)
+
+	tx, _ = p.repository.Db.Begin(ctx)
+	qtx = p.repository.WithTx(tx)
+
+	res := m.Run()
+	tx.Commit(ctx)
+	db.Close()
+	os.Exit(res)
+}
+
+func assembleTestEvent(privateKey *secp256k1.PrivateKey, blockHashHex, txHashHex string, blockHeight, txIndex int, 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 = testBlockHeigh
+		testBlockHeigh++
+	}
+	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
+}
--- a/modules/nodesale/processor.go
+++ b/modules/nodesale/processor.go
@@ -0,0 +1,290 @@
+package nodesale
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"log/slog"
+
+	"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"
+	"google.golang.org/protobuf/encoding/protojson"
+	"google.golang.org/protobuf/proto"
+
+	"github.com/gaze-network/indexer-network/core/datasources"
+	"github.com/gaze-network/indexer-network/modules/nodesale/protobuf"
+	repository "github.com/gaze-network/indexer-network/modules/nodesale/repository/postgres"
+	"github.com/gaze-network/indexer-network/modules/nodesale/repository/postgres/gen"
+)
+
+type Processor struct {
+	repository   *repository.Repository
+	btcClient    *datasources.BitcoinNodeDatasource
+	network      common.Network
+	cleanupFuncs []func(context.Context) error
+}
+
+// CurrentBlock implements indexer.Processor.
+func (p *Processor) CurrentBlock(ctx context.Context) (types.BlockHeader, error) {
+	block, err := p.repository.Queries.GetLastProcessedBlock(ctx)
+	if err != nil {
+		logger.InfoContext(ctx, "Couldn't get last processed block. Start from NODESALE_LAST_BLOCK_DEFAULT.",
+			slog.Int("currentBlock", NODESALE_LASTBLOCK_DEFAULT))
+		header, err := p.btcClient.GetBlockHeader(ctx, NODESALE_LASTBLOCK_DEFAULT)
+		if err != nil {
+			return types.BlockHeader{}, fmt.Errorf("Cannot get default block from bitcoin node : %w", err)
+		}
+		return types.BlockHeader{
+			Hash:   header.Hash,
+			Height: NODESALE_LASTBLOCK_DEFAULT,
+		}, 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: int64(block.BlockHeight),
+	}, nil
+}
+
+// GetIndexedBlock implements indexer.Processor.
+func (p *Processor) GetIndexedBlock(ctx context.Context, height int64) (types.BlockHeader, error) {
+	block, err := p.repository.Queries.GetBlock(ctx, int32(height))
+	if err != nil {
+		return types.BlockHeader{}, fmt.Errorf("Block %d not found : %w", height, err)
+	}
+	hash, err := chainhash.NewHashFromStr(block.BlockHash)
+	if err != nil {
+		logger.PanicContext(ctx, "Invalid hash format found in Database.")
+	}
+	return types.BlockHeader{
+		Hash:   *hash,
+		Height: int64(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:
+			if tokenizer.Opcode() == txscript.OP_PUSHDATA1 {
+				data := tokenizer.Data()
+				return data, controlBlock.InternalKey, true
+			}
+			state = 0
+		}
+	}
+	return []byte{}, nil, false
+}
+
+type nodesaleEvent struct {
+	transaction  *types.Transaction
+	eventMessage *protobuf.NodeSaleEvent
+	eventJson    []byte
+	// txAddress    btcutil.Address
+	txPubkey *btcec.PublicKey
+	rawData  []byte
+	// rawScript    []byte
+}
+
+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",
+					slog.String("block_hash", t.BlockHash.String()),
+					slog.Int("txIndex", int(t.Index)))
+				continue
+			}
+			eventJson, err := protojson.Marshal(event)
+			if err != nil {
+				return []nodesaleEvent{}, fmt.Errorf("Failed to parse protobuf to json : %w", err)
+			}
+
+			/*
+				outIndex := txIn.PreviousOutIndex
+				outHash := txIn.PreviousOutTxHash
+				result, err := p.btcClient.GetTransactionByHash(ctx, outHash)
+				if err != nil {
+					return []nodesaleEvent{}, fmt.Errorf("Failed to Get Bitcoin transaction : %w", err)
+				}
+				pkScript := result.TxOut[outIndex].PkScript
+				_, addresses, _, err := txscript.ExtractPkScriptAddrs(pkScript, p.network.ChainParams())
+				if err != nil {
+					return []nodesaleEvent{}, fmt.Errorf("Failed to Get Bitcoin address : %w", err)
+				}
+				if len(addresses) != 1 {
+					return []nodesaleEvent{}, fmt.Errorf("Multiple addresses detected.")
+				}*/
+
+			events = append(events, nodesaleEvent{
+				transaction:  t,
+				eventMessage: event,
+				eventJson:    eventJson,
+				// txAddress:    addresses[0],
+				rawData:  data,
+				txPubkey: txPubkey,
+				// rawScript:    rawScript,
+			})
+		}
+	}
+	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",
+			slog.Int64("block", block.Header.Height),
+			slog.String("hash", block.Header.Hash.String()))
+		// parse all event from each transaction including reading tx wallet
+		events, err := p.parseTransactions(ctx, block.Transactions)
+		if err != nil {
+			return fmt.Errorf("Invalid data from bitcoin client : %w", err)
+		}
+		// open transaction
+		tx, err := p.repository.Db.Begin(ctx)
+		if err != nil {
+			return fmt.Errorf("Failed to create transaction : %w", err)
+		}
+		defer tx.Rollback(ctx)
+		qtx := p.repository.WithTx(tx)
+
+		// write block
+		err = qtx.AddBlock(ctx, gen.AddBlockParams{
+			BlockHeight: int32(block.Header.Height),
+			BlockHash:   block.Header.Hash.String(),
+			Module:      p.Name(),
+		})
+		if err != nil {
+			return fmt.Errorf("Failed to add block %d : %w", block.Header.Height, err)
+		}
+		// for each events
+		for _, event := range events {
+			logger.InfoContext(ctx, "Nodesale processing event",
+				slog.Int("txIndex", int(event.transaction.Index)),
+				slog.Int("blockHeight", int(block.Header.Height)),
+				slog.String("blockhash", block.Header.Hash.String()),
+			)
+			eventMessage := event.eventMessage
+			switch eventMessage.Action {
+			case protobuf.Action_ACTION_DEPLOY:
+				err = p.processDeploy(ctx, qtx, block, event)
+				if err != nil {
+					return fmt.Errorf("Failed to deploy at block %d : %w", block.Header.Height, err)
+				}
+			case protobuf.Action_ACTION_DELEGATE:
+				err = p.processDelegate(ctx, qtx, block, event)
+				if err != nil {
+					return fmt.Errorf("Failed to delegate at block %d : %w", block.Header.Height, err)
+				}
+			case protobuf.Action_ACTION_PURCHASE:
+				err = p.processPurchase(ctx, qtx, block, event)
+				if err != nil {
+					return fmt.Errorf("Failed to purchase at block %d : %w", block.Header.Height, err)
+				}
+			}
+		}
+		// close transaction
+		err = tx.Commit(ctx)
+		if err != nil {
+			return fmt.Errorf("Failed to commit transaction : %w", err)
+		}
+		logger.InfoContext(ctx, "Nodesale finished processing block",
+			slog.Int64("block", block.Header.Height),
+			slog.String("hash", block.Header.Hash.String()))
+	}
+	return nil
+}
+
+// RevertData implements indexer.Processor.
+func (p *Processor) RevertData(ctx context.Context, from int64) error {
+	tx, err := p.repository.Db.Begin(ctx)
+	if err != nil {
+		return fmt.Errorf("Failed to create transaction : %w", err)
+	}
+	defer tx.Rollback(ctx)
+	qtx := p.repository.WithTx(tx)
+	_, err = qtx.RemoveBlockFrom(ctx, int32(from))
+	if err != nil {
+		return fmt.Errorf("Failed to remove blocks. : %w", err)
+	}
+
+	affected, err := qtx.RemoveEventsFromBlock(ctx, int32(from))
+	if err != nil {
+		return fmt.Errorf("Failed to remove events. : %w", err)
+	}
+	_, err = qtx.ClearDelegate(ctx)
+	if err != nil {
+		return fmt.Errorf("Failed to clear delegate from nodes : %w", err)
+	}
+	err = tx.Commit(ctx)
+	if err != nil {
+		return fmt.Errorf("Failed to commit transaction : %w", err)
+	}
+	logger.InfoContext(ctx, "Events removed",
+		slog.Int("Total removed", int(affected)))
+	return nil
+}
+
+// VerifyStates implements indexer.Processor.
+func (p *Processor) VerifyStates(ctx context.Context) error {
+	panic("unimplemented")
+}
+
+func (p *Processor) Shutdown(ctx context.Context) error {
+	for _, cleanupFunc := range p.cleanupFuncs {
+		err := cleanupFunc(ctx)
+		if err != nil {
+			return fmt.Errorf("cleanup function error : %w", err)
+		}
+	}
+	return nil
+}
+
+var _ indexer.Processor[*types.Block] = (*Processor)(nil)
--- a/modules/nodesale/processor_test.go
+++ b/modules/nodesale/processor_test.go
@@ -0,0 +1,7 @@
+package nodesale
+
+import "testing"
+
+func TestRevertData(t *testing.T) {
+	p.RevertData(ctx, 846855)
+}
--- a/modules/nodesale/protobuf/nodesale.pb.go
+++ b/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
+}
--- a/modules/nodesale/protobuf/nodesale.proto
+++ b/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;
+}
--- a/modules/nodesale/pubkeyaddr.go
+++ b/modules/nodesale/pubkeyaddr.go
@@ -0,0 +1,14 @@
+package nodesale
+
+import (
+	"github.com/btcsuite/btcd/btcec/v2"
+	"github.com/btcsuite/btcd/btcutil"
+)
+
+func (p *Processor) pubkeyToPkHashAddress(pubKey *btcec.PublicKey) btcutil.Address {
+	// pubKeyBytes, _ := hex.DecodeString(pubkey)
+	// pubKey, _ := btcec.ParsePubKey(pubKeyBytes)
+	addrPubKey, _ := btcutil.NewAddressPubKey(pubKey.SerializeCompressed(), p.network.ChainParams())
+	addrPubKeyHash := addrPubKey.AddressPubKeyHash()
+	return addrPubKeyHash
+}
--- a/modules/nodesale/purchase.go
+++ b/modules/nodesale/purchase.go
@@ -0,0 +1,270 @@
+package nodesale
+
+import (
+	"bytes"
+	"context"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"slices"
+
+	"github.com/btcsuite/btcd/btcec/v2"
+	"github.com/btcsuite/btcd/btcec/v2/ecdsa"
+	"github.com/btcsuite/btcd/btcutil"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/txscript"
+	"github.com/gaze-network/indexer-network/core/types"
+	"github.com/gaze-network/indexer-network/modules/nodesale/protobuf"
+	"github.com/gaze-network/indexer-network/modules/nodesale/repository/postgres/gen"
+	"github.com/jackc/pgx/v5/pgtype"
+	"google.golang.org/protobuf/encoding/protojson"
+	"google.golang.org/protobuf/proto"
+)
+
+type metaData struct {
+	ExpectedTotalAmountDiscounted int64
+	ReportedTotalAmount           int64
+	PaidTotalAmount               int64
+}
+
+func (p *Processor) processPurchase(ctx context.Context, qtx gen.Querier, block *types.Block, event nodesaleEvent) error {
+	valid := true
+	purchase := event.eventMessage.Purchase
+	payload := purchase.Payload
+
+	buyerPubkeyBytes, err := hex.DecodeString(payload.BuyerPublicKey)
+	if err != nil {
+		valid = false
+	}
+
+	if valid {
+		buyerPubkey, err := btcec.ParsePubKey(buyerPubkeyBytes)
+		if err != nil {
+			valid = false
+		}
+		if valid && !event.txPubkey.IsEqual(buyerPubkey) {
+			valid = false
+		}
+	}
+
+	var deploy *gen.NodeSale
+	if valid {
+		// check node existed
+		deploys, err := qtx.GetNodesale(ctx, gen.GetNodesaleParams{
+			BlockHeight: int32(payload.DeployID.Block),
+			TxIndex:     int32(payload.DeployID.TxIndex),
+		})
+		if err != nil {
+			return fmt.Errorf("Failed to Get nodesale : %w", err)
+		}
+		if len(deploys) < 1 {
+			valid = false
+		} else {
+			deploy = &deploys[0]
+		}
+	}
+
+	if valid {
+		// check timestamp
+		timestamp := block.Header.Timestamp
+		if timestamp.UTC().Before(deploy.StartsAt.Time.UTC()) ||
+			timestamp.UTC().After(deploy.EndsAt.Time.UTC()) {
+			valid = false
+		}
+	}
+
+	if valid {
+		if payload.TimeOutBlock < uint64(event.transaction.BlockHeight) {
+			valid = false
+		}
+	}
+
+	if valid {
+		// verified signature
+		payloadBytes, _ := proto.Marshal(payload)
+		signatureBytes, _ := hex.DecodeString(purchase.SellerSignature)
+		signature, err := ecdsa.ParseSignature(signatureBytes)
+		if err != nil {
+			valid = false
+		}
+		if valid {
+			hash := chainhash.DoubleHashB(payloadBytes)
+			pubkeyBytes, _ := hex.DecodeString(deploy.SellerPublicKey)
+			pubKey, _ := btcec.ParsePubKey(pubkeyBytes)
+			verified := signature.Verify(hash[:], pubKey)
+			if !verified {
+				valid = false
+			}
+		}
+	}
+
+	var tiers []protobuf.Tier
+	var buyingTiersCount []uint32
+	nodeIdToTier := make(map[uint32]int32, 1)
+	if valid {
+		// valid nodeID tier
+		tiers = make([]protobuf.Tier, len(deploy.Tiers))
+		for i, tierJson := range deploy.Tiers {
+			tier := &tiers[i]
+			err := protojson.Unmarshal(tierJson, tier)
+			if err != nil {
+				return fmt.Errorf("Failed to decode tiers json : %w", err)
+			}
+		}
+		slices.Sort(payload.NodeIDs)
+		buyingTiersCount = make([]uint32, len(tiers))
+		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 {
+				valid = false
+			}
+		}
+	}
+
+	if valid {
+		// valid unpurchased node ID
+		nodeIds := make([]int32, len(payload.NodeIDs))
+		for i, id := range payload.NodeIDs {
+			nodeIds[i] = int32(id)
+		}
+		nodes, err := qtx.GetNodes(ctx, gen.GetNodesParams{
+			SaleBlock:   int32(payload.DeployID.Block),
+			SaleTxIndex: int32(payload.DeployID.TxIndex),
+			NodeIds:     nodeIds,
+		})
+		if err != nil {
+			return fmt.Errorf("Failed to Get nodes : %w", err)
+		}
+		if len(nodes) > 0 {
+			valid = false
+		}
+	}
+
+	var sellerAddr btcutil.Address
+	if valid {
+		sellerAddr, err = btcutil.DecodeAddress(deploy.SellerWallet, p.network.ChainParams())
+		if err != nil {
+			valid = false
+		}
+	}
+
+	var txPaid int64 = 0
+	meta := metaData{}
+	if valid {
+		// get total amount paid to seller
+		for _, txOut := range event.transaction.TxOut {
+			_, txOutAddrs, _, _ := txscript.ExtractPkScriptAddrs(txOut.PkScript, p.network.ChainParams())
+			if len(txOutAddrs) == 1 && bytes.Equal(
+				[]byte(sellerAddr.EncodeAddress()),
+				[]byte(txOutAddrs[0].EncodeAddress()),
+			) {
+				txPaid += txOut.Value
+			}
+		}
+		meta.PaidTotalAmount = txPaid
+		meta.ReportedTotalAmount = payload.TotalAmountSat
+		// total amount paid is greater than report paid
+		if txPaid < payload.TotalAmountSat {
+			valid = false
+		}
+		// calculate total price
+		var totalPrice int64 = 0
+		for i := 0; i < len(tiers); i++ {
+			totalPrice += int64(buyingTiersCount[i] * tiers[i].PriceSat)
+		}
+		// report paid is greater than max discounted total price
+		maxDiscounted := totalPrice * (100 - int64(deploy.MaxDiscountPercentage))
+		decimal := maxDiscounted % 100
+		maxDiscounted /= 100
+		if decimal%100 >= 50 {
+			maxDiscounted++
+		}
+		meta.ExpectedTotalAmountDiscounted = maxDiscounted
+		if payload.TotalAmountSat < maxDiscounted {
+			valid = false
+		}
+	}
+
+	var buyerOwnedNodes []gen.Node
+	if valid {
+		var err error
+		// check node limit
+		// get all selled by seller and owned by buyer
+		buyerOwnedNodes, err = qtx.GetNodesByOwner(ctx, gen.GetNodesByOwnerParams{
+			SaleBlock:      deploy.BlockHeight,
+			SaleTxIndex:    deploy.TxIndex,
+			OwnerPublicKey: payload.BuyerPublicKey,
+		})
+		if err != nil {
+			return fmt.Errorf("Failed to GetNodesByOwner : %w", err)
+		}
+		if len(buyerOwnedNodes)+len(payload.NodeIDs) > int(deploy.MaxPerAddress) {
+			valid = false
+		}
+	}
+
+	if valid {
+		// 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 {
+				valid = false
+				break
+			}
+		}
+	}
+
+	metaDataBytes, _ := json.Marshal(meta)
+
+	err = qtx.AddEvent(ctx, gen.AddEventParams{
+		TxHash:         event.transaction.TxHash.String(),
+		TxIndex:        int32(event.transaction.Index),
+		Action:         int32(event.eventMessage.Action),
+		RawMessage:     event.rawData,
+		ParsedMessage:  event.eventJson,
+		BlockTimestamp: pgtype.Timestamp{Time: block.Header.Timestamp, Valid: true},
+		BlockHash:      event.transaction.BlockHash.String(),
+		BlockHeight:    int32(event.transaction.BlockHeight),
+		Valid:          valid,
+		// WalletAddress:  event.txAddress.EncodeAddress(),
+		WalletAddress: p.pubkeyToPkHashAddress(event.txPubkey).EncodeAddress(),
+		Metadata:      metaDataBytes,
+	})
+	if err != nil {
+		return fmt.Errorf("Failed to insert event : %w", err)
+	}
+
+	if valid {
+		// add to node
+		for _, nodeId := range payload.NodeIDs {
+			err := qtx.AddNode(ctx, gen.AddNodeParams{
+				SaleBlock:      deploy.BlockHeight,
+				SaleTxIndex:    deploy.TxIndex,
+				NodeID:         int32(nodeId),
+				TierIndex:      nodeIdToTier[nodeId],
+				DelegatedTo:    "",
+				OwnerPublicKey: payload.BuyerPublicKey,
+				PurchaseTxHash: event.transaction.TxHash.String(),
+				DelegateTxHash: "",
+			})
+			if err != nil {
+				return fmt.Errorf("Failed to insert node : %w", err)
+			}
+		}
+	}
+
+	return nil
+}
--- a/modules/nodesale/purchase_test.go
+++ b/modules/nodesale/purchase_test.go
@@ -0,0 +1,686 @@
+package nodesale
+
+import (
+	"encoding/hex"
+	"testing"
+	"time"
+
+	"github.com/btcsuite/btcd/btcec/v2"
+	"github.com/btcsuite/btcd/btcutil"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/txscript"
+	"github.com/decred/dcrd/dcrec/secp256k1/v4/ecdsa"
+	"github.com/gaze-network/indexer-network/core/types"
+	"github.com/gaze-network/indexer-network/modules/nodesale/protobuf"
+	"github.com/gaze-network/indexer-network/modules/nodesale/repository/postgres/gen"
+	"github.com/stretchr/testify/require"
+	"google.golang.org/protobuf/proto"
+)
+
+func TestInvalidPurchase(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping test in short mode.")
+	}
+	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:   111,
+					TxIndex: 1,
+				},
+				NodeIDs:        []uint32{1, 2},
+				BuyerPublicKey: buyerPubkeyHex,
+				TotalAmountSat: 500,
+				TimeOutBlock:   uint64(testBlockHeigh) + 5,
+			},
+		},
+	}
+
+	event, block := assembleTestEvent(buyerPrivateKey, "030303030303", "030303030303", 0, 0, message)
+
+	p.processPurchase(ctx, qtx, block, event)
+
+	nodes, _ := qtx.GetNodes(ctx, gen.GetNodesParams{
+		SaleBlock:   111,
+		SaleTxIndex: 1,
+		NodeIds:     []int32{1, 2},
+	})
+	require.Len(t, nodes, 0)
+}
+
+func TestInvalidTimestamp(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping test in short mode.")
+	}
+	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)
+	deployMessage := &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:       sellerPubkeyHex,
+			MaxPerAddress:         100,
+			MaxDiscountPercentage: 50,
+			SellerWallet:          sellerWallet.EncodeAddress(),
+		},
+	}
+	event, block := assembleTestEvent(sellerPrivateKey, "040404040404", "040404040404", 0, 0, deployMessage)
+	p.processDeploy(ctx, qtx, block, event)
+
+	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:   uint64(testBlockHeigh) - 1,
+					TxIndex: uint32(testTxIndex) - 1,
+				},
+				NodeIDs:        []uint32{1, 2},
+				BuyerPublicKey: buyerPubkeyHex,
+				TotalAmountSat: 200,
+				TimeOutBlock:   uint64(testBlockHeigh) + 5,
+			},
+		},
+	}
+
+	event, block = assembleTestEvent(buyerPrivateKey, "050505050505", "050505050505", 0, 0, message)
+	block.Header.Timestamp = time.Now().UTC().Add(time.Hour * 2)
+	p.processPurchase(ctx, qtx, block, event)
+
+	nodes, _ := qtx.GetNodes(ctx, gen.GetNodesParams{
+		SaleBlock:   int32(testBlockHeigh) - 2,
+		SaleTxIndex: int32(testTxIndex) - 2,
+		NodeIds:     []int32{1, 2},
+	})
+	require.Len(t, nodes, 0)
+}
+
+func TestInvalidBuyerKey(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping test in short mode.")
+	}
+	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)
+	deployMessage := &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:       sellerPubkeyHex,
+			MaxPerAddress:         100,
+			MaxDiscountPercentage: 50,
+			SellerWallet:          sellerWallet.EncodeAddress(),
+		},
+	}
+	event, block := assembleTestEvent(sellerPrivateKey, "060606060606", "060606060606", 0, 0, deployMessage)
+	p.processDeploy(ctx, qtx, block, event)
+
+	buyerPrivateKey, _ := btcec.NewPrivateKey()
+
+	message := &protobuf.NodeSaleEvent{
+		Action: protobuf.Action_ACTION_PURCHASE,
+		Purchase: &protobuf.ActionPurchase{
+			Payload: &protobuf.PurchasePayload{
+				DeployID: &protobuf.ActionID{
+					Block:   uint64(testBlockHeigh) - 1,
+					TxIndex: uint32(testTxIndex) - 1,
+				},
+				NodeIDs:        []uint32{1, 2},
+				BuyerPublicKey: sellerPubkeyHex,
+				TotalAmountSat: 200,
+				TimeOutBlock:   uint64(testBlockHeigh) + 5,
+			},
+		},
+	}
+
+	event, block = assembleTestEvent(buyerPrivateKey, "0707070707", "0707070707", 0, 0, message)
+	block.Header.Timestamp = time.Now().UTC().Add(time.Hour * 2)
+	p.processPurchase(ctx, qtx, block, event)
+	nodes, _ := qtx.GetNodes(ctx, gen.GetNodesParams{
+		SaleBlock:   int32(testBlockHeigh) - 2,
+		SaleTxIndex: int32(testTxIndex) - 2,
+		NodeIds:     []int32{1, 2},
+	})
+	require.Len(t, nodes, 0)
+}
+
+func TestTimeOut(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping test in short mode.")
+	}
+	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)
+	deployMessage := &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:       sellerPubkeyHex,
+			MaxPerAddress:         100,
+			MaxDiscountPercentage: 50,
+			SellerWallet:          sellerWallet.EncodeAddress(),
+		},
+	}
+	event, block := assembleTestEvent(sellerPrivateKey, "0808080808", "0808080808", 0, 0, deployMessage)
+	p.processDeploy(ctx, qtx, block, event)
+
+	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:   uint64(testBlockHeigh) - 1,
+					TxIndex: uint32(testTxIndex) - 1,
+				},
+				NodeIDs:        []uint32{1, 2},
+				BuyerPublicKey: buyerPubkeyHex,
+				TimeOutBlock:   uint64(testBlockHeigh) - 5,
+				TotalAmountSat: 200,
+			},
+		},
+	}
+
+	event, block = assembleTestEvent(buyerPrivateKey, "090909090909", "090909090909", 0, 0, message)
+	p.processPurchase(ctx, qtx, block, event)
+	nodes, _ := qtx.GetNodes(ctx, gen.GetNodesParams{
+		SaleBlock:   int32(testBlockHeigh) - 2,
+		SaleTxIndex: int32(testTxIndex) - 2,
+		NodeIds:     []int32{1, 2},
+	})
+	require.Len(t, nodes, 0)
+}
+
+func TestSignatureInvalid(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping test in short mode.")
+	}
+	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)
+	deployMessage := &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:       sellerPubkeyHex,
+			MaxPerAddress:         100,
+			MaxDiscountPercentage: 50,
+			SellerWallet:          sellerWallet.EncodeAddress(),
+		},
+	}
+	event, block := assembleTestEvent(sellerPrivateKey, "0A0A0A0A", "0A0A0A0A", 0, 0, deployMessage)
+	p.processDeploy(ctx, qtx, block, event)
+
+	buyerPrivateKey, _ := btcec.NewPrivateKey()
+	buyerPubkeyHex := hex.EncodeToString(buyerPrivateKey.PubKey().SerializeCompressed())
+
+	payload := &protobuf.PurchasePayload{
+		DeployID: &protobuf.ActionID{
+			Block:   uint64(testBlockHeigh) - 1,
+			TxIndex: uint32(testTxIndex) - 1,
+		},
+		NodeIDs:        []uint32{1, 2},
+		BuyerPublicKey: buyerPubkeyHex,
+		TimeOutBlock:   uint64(testBlockHeigh) + 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)
+	p.processPurchase(ctx, qtx, block, event)
+	nodes, _ := qtx.GetNodes(ctx, gen.GetNodesParams{
+		SaleBlock:   int32(testBlockHeigh) - 2,
+		SaleTxIndex: int32(testTxIndex) - 2,
+		NodeIds:     []int32{1, 2},
+	})
+	require.Len(t, nodes, 0)
+}
+
+func TestValidPurchase(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping test in short mode.")
+	}
+	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)
+	deployMessage := &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:         4,
+					MaxPerAddress: 2,
+				},
+				{
+					PriceSat:      400,
+					Limit:         3,
+					MaxPerAddress: 100,
+				},
+			},
+			SellerPublicKey:       sellerPubkeyHex,
+			MaxPerAddress:         100,
+			MaxDiscountPercentage: 50,
+			SellerWallet:          sellerWallet.EncodeAddress(),
+		},
+	}
+	event, block := assembleTestEvent(sellerPrivateKey, "0C0C0C0C0C", "0C0C0C0C0C", 0, 0, deployMessage)
+	p.processDeploy(ctx, qtx, block, event)
+
+	buyerPrivateKey, _ := btcec.NewPrivateKey()
+	buyerPubkeyHex := hex.EncodeToString(buyerPrivateKey.PubKey().SerializeCompressed())
+
+	payload := &protobuf.PurchasePayload{
+		DeployID: &protobuf.ActionID{
+			Block:   uint64(testBlockHeigh) - 1,
+			TxIndex: uint32(testTxIndex) - 1,
+		},
+		BuyerPublicKey: buyerPubkeyHex,
+		TimeOutBlock:   uint64(testBlockHeigh) + 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)
+
+	addr, _ := btcutil.NewAddressPubKey(sellerPrivateKey.PubKey().SerializeCompressed(), p.network.ChainParams())
+	pkscript, _ := txscript.PayToAddrScript(addr.AddressPubKeyHash())
+	event.transaction.TxOut = []*types.TxOut{
+		{
+			PkScript: pkscript,
+			Value:    500,
+		},
+	}
+	p.processPurchase(ctx, qtx, block, event)
+	nodes, _ := qtx.GetNodes(ctx, gen.GetNodesParams{
+		SaleBlock:   int32(testBlockHeigh) - 2,
+		SaleTxIndex: int32(testTxIndex) - 2,
+		NodeIds:     []int32{0, 5, 6, 9},
+	})
+	require.Len(t, nodes, 4)
+	ids := make([]int32, len(nodes))
+	for i, id := range nodes {
+		ids[i] = id.NodeID
+	}
+	require.Contains(t, ids, int32(0))
+	require.Contains(t, ids, int32(5))
+	require.Contains(t, ids, int32(6))
+	require.Contains(t, ids, int32(9))
+}
+
+func TestBuyingLimit(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping test in short mode.")
+	}
+	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)
+	deployMessage := &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:         4,
+					MaxPerAddress: 2,
+				},
+				{
+					PriceSat:      400,
+					Limit:         50,
+					MaxPerAddress: 100,
+				},
+			},
+			SellerPublicKey:       sellerPubkeyHex,
+			MaxPerAddress:         2,
+			MaxDiscountPercentage: 50,
+			SellerWallet:          sellerWallet.EncodeAddress(),
+		},
+	}
+	event, block := assembleTestEvent(sellerPrivateKey, "2121212121", "2121212121", 0, 0, deployMessage)
+	p.processDeploy(ctx, qtx, block, event)
+
+	buyerPrivateKey, _ := btcec.NewPrivateKey()
+	buyerPubkeyHex := hex.EncodeToString(buyerPrivateKey.PubKey().SerializeCompressed())
+
+	payload := &protobuf.PurchasePayload{
+		DeployID: &protobuf.ActionID{
+			Block:   uint64(testBlockHeigh) - 1,
+			TxIndex: uint32(testTxIndex) - 1,
+		},
+		BuyerPublicKey: buyerPubkeyHex,
+		TimeOutBlock:   uint64(testBlockHeigh) + 5,
+		NodeIDs:        []uint32{9, 10},
+		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, "2020202020", "2020202020", 0, 0, message)
+
+	addr, _ := btcutil.NewAddressPubKey(sellerPrivateKey.PubKey().SerializeCompressed(), p.network.ChainParams())
+	pkscript, _ := txscript.PayToAddrScript(addr.AddressPubKeyHash())
+	event.transaction.TxOut = []*types.TxOut{
+		{
+			PkScript: pkscript,
+			Value:    600,
+		},
+	}
+	p.processPurchase(ctx, qtx, block, event)
+
+	tx.Commit(ctx)
+	tx, _ = p.repository.Db.Begin(ctx)
+	qtx = p.repository.WithTx(tx)
+
+	payload = &protobuf.PurchasePayload{
+		DeployID: &protobuf.ActionID{
+			Block:   uint64(testBlockHeigh) - 2,
+			TxIndex: uint32(testTxIndex) - 2,
+		},
+		BuyerPublicKey: buyerPubkeyHex,
+		TimeOutBlock:   uint64(testBlockHeigh) + 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)
+
+	addr, _ = btcutil.NewAddressPubKey(sellerPrivateKey.PubKey().SerializeCompressed(), p.network.ChainParams())
+	pkscript, _ = txscript.PayToAddrScript(addr.AddressPubKeyHash())
+	event.transaction.TxOut = []*types.TxOut{
+		{
+			PkScript: pkscript,
+			Value:    600,
+		},
+	}
+	p.processPurchase(ctx, qtx, block, event)
+
+	nodes, _ := qtx.GetNodes(ctx, gen.GetNodesParams{
+		SaleBlock:   int32(testBlockHeigh) - 3,
+		SaleTxIndex: int32(testTxIndex) - 3,
+		NodeIds:     []int32{9, 10, 11},
+	})
+	require.Len(t, nodes, 2)
+	ids := make([]int32, len(nodes))
+	for i, id := range nodes {
+		ids[i] = id.NodeID
+	}
+	require.Contains(t, ids, int32(9))
+	require.Contains(t, ids, int32(10))
+}
+
+func TestBuyingTierLimit(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping test in short mode.")
+	}
+	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)
+	deployMessage := &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:         4,
+					MaxPerAddress: 2,
+				},
+				{
+					PriceSat:      400,
+					Limit:         50,
+					MaxPerAddress: 3,
+				},
+			},
+			SellerPublicKey:       sellerPubkeyHex,
+			MaxPerAddress:         100,
+			MaxDiscountPercentage: 50,
+			SellerWallet:          sellerWallet.EncodeAddress(),
+		},
+	}
+	event, block := assembleTestEvent(sellerPrivateKey, "0E0E0E0E", "0E0E0E0E", 0, 0, deployMessage)
+	p.processDeploy(ctx, qtx, block, event)
+
+	buyerPrivateKey, _ := btcec.NewPrivateKey()
+	buyerPubkeyHex := hex.EncodeToString(buyerPrivateKey.PubKey().SerializeCompressed())
+
+	payload := &protobuf.PurchasePayload{
+		DeployID: &protobuf.ActionID{
+			Block:   uint64(testBlockHeigh) - 1,
+			TxIndex: uint32(testTxIndex) - 1,
+		},
+		BuyerPublicKey: buyerPubkeyHex,
+		TimeOutBlock:   uint64(testBlockHeigh) + 5,
+		NodeIDs:        []uint32{9, 10, 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, "0F0F0F0F0F", "0F0F0F0F0F", 0, 0, message)
+
+	addr, _ := btcutil.NewAddressPubKey(sellerPrivateKey.PubKey().SerializeCompressed(), p.network.ChainParams())
+	pkscript, _ := txscript.PayToAddrScript(addr.AddressPubKeyHash())
+	event.transaction.TxOut = []*types.TxOut{
+		{
+			PkScript: pkscript,
+			Value:    600,
+		},
+	}
+	p.processPurchase(ctx, qtx, block, event)
+
+	tx.Commit(ctx)
+	tx, _ = p.repository.Db.Begin(ctx)
+	qtx = p.repository.WithTx(tx)
+
+	payload = &protobuf.PurchasePayload{
+		DeployID: &protobuf.ActionID{
+			Block:   uint64(testBlockHeigh) - 2,
+			TxIndex: uint32(testTxIndex) - 2,
+		},
+		BuyerPublicKey: buyerPubkeyHex,
+		TimeOutBlock:   uint64(testBlockHeigh) + 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)
+
+	addr, _ = btcutil.NewAddressPubKey(sellerPrivateKey.PubKey().SerializeCompressed(), p.network.ChainParams())
+	pkscript, _ = txscript.PayToAddrScript(addr.AddressPubKeyHash())
+	event.transaction.TxOut = []*types.TxOut{
+		{
+			PkScript: pkscript,
+			Value:    600,
+		},
+	}
+	p.processPurchase(ctx, qtx, block, event)
+
+	nodes, _ := qtx.GetNodes(ctx, gen.GetNodesParams{
+		SaleBlock:   int32(testBlockHeigh) - 3,
+		SaleTxIndex: int32(testTxIndex) - 3,
+		NodeIds:     []int32{9, 10, 11, 12, 13, 14},
+	})
+	require.Len(t, nodes, 3)
+	ids := make([]int32, len(nodes))
+	for i, id := range nodes {
+		ids[i] = id.NodeID
+	}
+	require.Contains(t, ids, int32(9))
+	require.Contains(t, ids, int32(10))
+	require.Contains(t, ids, int32(11))
+}
--- a/modules/nodesale/repository/postgres/gen/blocks.sql.go
+++ b/modules/nodesale/repository/postgres/gen/blocks.sql.go
@@ -0,0 +1,63 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.26.0
+// source: blocks.sql
+
+package gen
+
+import (
+	"context"
+)
+
+const addBlock = `-- name: AddBlock :exec
+INSERT INTO blocks("block_height", "block_hash", "module")
+VALUES ($1, $2, $3)
+`
+
+type AddBlockParams struct {
+	BlockHeight int32
+	BlockHash   string
+	Module      string
+}
+
+func (q *Queries) AddBlock(ctx context.Context, arg AddBlockParams) error {
+	_, err := q.db.Exec(ctx, addBlock, 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 int32) (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
+WHERE "block_height" = (SELECT MAX("block_height") FROM blocks)
+`
+
+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 int32) (int64, error) {
+	result, err := q.db.Exec(ctx, removeBlockFrom, fromBlock)
+	if err != nil {
+		return 0, err
+	}
+	return result.RowsAffected(), nil
+}
--- a/modules/nodesale/repository/postgres/gen/db.go
+++ b/modules/nodesale/repository/postgres/gen/db.go
@@ -0,0 +1,32 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.26.0
+
+package gen
+
+import (
+	"context"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgconn"
+)
+
+type DBTX interface {
+	Exec(context.Context, string, ...interface{}) (pgconn.CommandTag, error)
+	Query(context.Context, string, ...interface{}) (pgx.Rows, error)
+	QueryRow(context.Context, string, ...interface{}) pgx.Row
+}
+
+func New(db DBTX) *Queries {
+	return &Queries{db: db}
+}
+
+type Queries struct {
+	db DBTX
+}
+
+func (q *Queries) WithTx(tx pgx.Tx) *Queries {
+	return &Queries{
+		db: tx,
+	}
+}
--- a/modules/nodesale/repository/postgres/gen/events.sql.go
+++ b/modules/nodesale/repository/postgres/gen/events.sql.go
@@ -0,0 +1,100 @@
+// 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 addEvent = `-- name: AddEvent :exec
+INSERT INTO events("tx_hash", "block_height", "tx_index", "wallet_address", "valid", "action", 
+                    "raw_message", "parsed_message", "block_timestamp", "block_hash", "metadata")
+VALUES ( $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
+`
+
+type AddEventParams struct {
+	TxHash         string
+	BlockHeight    int32
+	TxIndex        int32
+	WalletAddress  string
+	Valid          bool
+	Action         int32
+	RawMessage     []byte
+	ParsedMessage  []byte
+	BlockTimestamp pgtype.Timestamp
+	BlockHash      string
+	Metadata       []byte
+}
+
+func (q *Queries) AddEvent(ctx context.Context, arg AddEventParams) error {
+	_, err := q.db.Exec(ctx, addEvent,
+		arg.TxHash,
+		arg.BlockHeight,
+		arg.TxIndex,
+		arg.WalletAddress,
+		arg.Valid,
+		arg.Action,
+		arg.RawMessage,
+		arg.ParsedMessage,
+		arg.BlockTimestamp,
+		arg.BlockHash,
+		arg.Metadata,
+	)
+	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
+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,
+		); 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 int32) (int64, error) {
+	result, err := q.db.Exec(ctx, removeEventsFromBlock, fromBlock)
+	if err != nil {
+		return 0, err
+	}
+	return result.RowsAffected(), nil
+}
--- a/modules/nodesale/repository/postgres/gen/models.go
+++ b/modules/nodesale/repository/postgres/gen/models.go
@@ -0,0 +1,54 @@
+// 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 int32
+	BlockHash   string
+	Module      string
+}
+
+type Event struct {
+	TxHash         string
+	BlockHeight    int32
+	TxIndex        int32
+	WalletAddress  string
+	Valid          bool
+	Action         int32
+	RawMessage     []byte
+	ParsedMessage  []byte
+	BlockTimestamp pgtype.Timestamp
+	BlockHash      string
+	Metadata       []byte
+}
+
+type Node struct {
+	SaleBlock      int32
+	SaleTxIndex    int32
+	NodeID         int32
+	TierIndex      int32
+	DelegatedTo    string
+	OwnerPublicKey string
+	PurchaseTxHash string
+	DelegateTxHash string
+}
+
+type NodeSale struct {
+	BlockHeight           int32
+	TxIndex               int32
+	Name                  string
+	StartsAt              pgtype.Timestamp
+	EndsAt                pgtype.Timestamp
+	Tiers                 [][]byte
+	SellerPublicKey       string
+	MaxPerAddress         int32
+	DeployTxHash          string
+	MaxDiscountPercentage int32
+	SellerWallet          string
+}
--- a/modules/nodesale/repository/postgres/gen/nodes.sql.go
+++ b/modules/nodesale/repository/postgres/gen/nodes.sql.go
@@ -0,0 +1,304 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.26.0
+// source: nodes.sql
+
+package gen
+
+import (
+	"context"
+
+	"github.com/jackc/pgx/v5/pgtype"
+)
+
+const addNode = `-- name: AddNode :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 AddNodeParams struct {
+	SaleBlock      int32
+	SaleTxIndex    int32
+	NodeID         int32
+	TierIndex      int32
+	DelegatedTo    string
+	OwnerPublicKey string
+	PurchaseTxHash string
+	DelegateTxHash string
+}
+
+func (q *Queries) AddNode(ctx context.Context, arg AddNodeParams) error {
+	_, err := q.db.Exec(ctx, addNode,
+		arg.SaleBlock,
+		arg.SaleTxIndex,
+		arg.NodeID,
+		arg.TierIndex,
+		arg.DelegatedTo,
+		arg.OwnerPublicKey,
+		arg.PurchaseTxHash,
+		arg.DelegateTxHash,
+	)
+	return err
+}
+
+const clearDelegate = `-- name: ClearDelegate :execrows
+UPDATE nodes
+SET "delegated_to" = ''
+WHERE "delegate_tx_hash" = NULL
+`
+
+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 getNodeCountByTierIndex = `-- name: GetNodeCountByTierIndex :many
+SELECT tiers.tier_index 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   int32
+	SaleTxIndex int32
+	FromTier    int32
+	ToTier      int32
+}
+
+type GetNodeCountByTierIndexRow struct {
+	TierIndex interface{}
+	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 getNodes = `-- name: GetNodes :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 GetNodesParams struct {
+	SaleBlock   int32
+	SaleTxIndex int32
+	NodeIds     []int32
+}
+
+func (q *Queries) GetNodes(ctx context.Context, arg GetNodesParams) ([]Node, error) {
+	rows, err := q.db.Query(ctx, getNodes, 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      int32
+	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 sale_block, sale_tx_index, node_id, tier_index, delegated_to, owner_public_key, purchase_tx_hash, delegate_tx_hash, tx_hash, block_height, tx_index, wallet_address, valid, action, raw_message, parsed_message, block_timestamp, block_hash, metadata
+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      int32
+	SaleTxIndex    int32
+	OwnerPublicKey string
+	DelegatedTo    string
+}
+
+type GetNodesByPubkeyRow struct {
+	SaleBlock      int32
+	SaleTxIndex    int32
+	NodeID         int32
+	TierIndex      int32
+	DelegatedTo    string
+	OwnerPublicKey string
+	PurchaseTxHash string
+	DelegateTxHash string
+	TxHash         string
+	BlockHeight    int32
+	TxIndex        int32
+	WalletAddress  string
+	Valid          bool
+	Action         int32
+	RawMessage     []byte
+	ParsedMessage  []byte
+	BlockTimestamp pgtype.Timestamp
+	BlockHash      string
+	Metadata       []byte
+}
+
+func (q *Queries) GetNodesByPubkey(ctx context.Context, arg GetNodesByPubkeyParams) ([]GetNodesByPubkeyRow, 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 []GetNodesByPubkeyRow
+	for rows.Next() {
+		var i GetNodesByPubkeyRow
+		if err := rows.Scan(
+			&i.SaleBlock,
+			&i.SaleTxIndex,
+			&i.NodeID,
+			&i.TierIndex,
+			&i.DelegatedTo,
+			&i.OwnerPublicKey,
+			&i.PurchaseTxHash,
+			&i.DelegateTxHash,
+			&i.TxHash,
+			&i.BlockHeight,
+			&i.TxIndex,
+			&i.WalletAddress,
+			&i.Valid,
+			&i.Action,
+			&i.RawMessage,
+			&i.ParsedMessage,
+			&i.BlockTimestamp,
+			&i.BlockHash,
+			&i.Metadata,
+		); 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 = $3
+WHERE sale_block = $1 AND
+    sale_tx_index = $2 AND
+    node_id = ANY ($4::int[])
+`
+
+type SetDelegatesParams struct {
+	SaleBlock   int32
+	SaleTxIndex int32
+	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.Delegatee,
+		arg.NodeIds,
+	)
+	if err != nil {
+		return 0, err
+	}
+	return result.RowsAffected(), nil
+}
--- a/modules/nodesale/repository/postgres/gen/nodesales.sql.go
+++ b/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 addNodesale = `-- name: AddNodesale :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 AddNodesaleParams struct {
+	BlockHeight           int32
+	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) AddNodesale(ctx context.Context, arg AddNodesaleParams) error {
+	_, err := q.db.Exec(ctx, addNodesale,
+		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 int32
+	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
+}
--- a/modules/nodesale/repository/postgres/gen/querier.go
+++ b/modules/nodesale/repository/postgres/gen/querier.go
@@ -0,0 +1,31 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.26.0
+
+package gen
+
+import (
+	"context"
+)
+
+type Querier interface {
+	AddBlock(ctx context.Context, arg AddBlockParams) error
+	AddEvent(ctx context.Context, arg AddEventParams) error
+	AddNode(ctx context.Context, arg AddNodeParams) error
+	AddNodesale(ctx context.Context, arg AddNodesaleParams) error
+	ClearDelegate(ctx context.Context) (int64, error)
+	ClearEvents(ctx context.Context) error
+	GetBlock(ctx context.Context, blockHeight int32) (Block, error)
+	GetEventsByWallet(ctx context.Context, walletAddress string) ([]Event, error)
+	GetLastProcessedBlock(ctx context.Context) (Block, error)
+	GetNodeCountByTierIndex(ctx context.Context, arg GetNodeCountByTierIndexParams) ([]GetNodeCountByTierIndexRow, error)
+	GetNodes(ctx context.Context, arg GetNodesParams) ([]Node, error)
+	GetNodesByOwner(ctx context.Context, arg GetNodesByOwnerParams) ([]Node, error)
+	GetNodesByPubkey(ctx context.Context, arg GetNodesByPubkeyParams) ([]GetNodesByPubkeyRow, error)
+	GetNodesale(ctx context.Context, arg GetNodesaleParams) ([]NodeSale, error)
+	RemoveBlockFrom(ctx context.Context, fromBlock int32) (int64, error)
+	RemoveEventsFromBlock(ctx context.Context, fromBlock int32) (int64, error)
+	SetDelegates(ctx context.Context, arg SetDelegatesParams) (int64, error)
+}
+
+var _ Querier = (*Queries)(nil)
--- a/modules/nodesale/repository/postgres/gen/test.sql.go
+++ b/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
+}
--- a/modules/nodesale/repository/postgres/repository.go
+++ b/modules/nodesale/repository/postgres/repository.go
@@ -0,0 +1,24 @@
+package postgres
+
+import (
+	db "github.com/gaze-network/indexer-network/internal/postgres"
+	"github.com/gaze-network/indexer-network/modules/nodesale/repository/postgres/gen"
+	"github.com/jackc/pgx/v5"
+)
+
+type Repository struct {
+	Db      db.TxQueryable
+	Queries gen.Querier
+}
+
+func NewRepository(db db.DB) *Repository {
+	return &Repository{
+		Db:      db,
+		Queries: gen.New(db),
+	}
+}
+
+func (q *Repository) WithTx(tx pgx.Tx) gen.Querier {
+	queries := gen.Queries{}
+	return queries.WithTx(tx)
+}
--- a/modules/nodesale/tapscript.go
+++ b/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
+}
--- a/sqlc.yaml
+++ b/sqlc.yaml
@@ -17,3 +17,11 @@ sql:
        sql_package: "pgx/v5"
        rename:
          id: "Id"
+  - schema: "./modules/nodesale/database/postgresql/migrations"
+    queries: "./modules/nodesale/database/postgresql/queries"
+    engine: "postgresql"
+    gen:
+      go:
+        package: "gen"
+        out: "./modules/nodesale/repository/postgres/gen"
+        sql_package: "pgx/v5"