fix: handle block timeout = 0

.vscode/settings.json

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

core/datasources/bitcoin_node.go

@@ -285,12 +285,3 @@ func (d *BitcoinNodeDatasource) GetBlockHeader(ctx context.Context, height int64
 
 	return types.ParseMsgBlockHeader(*block, height), nil
 }
-
-func (d *BitcoinNodeDatasource) GetRawTransactionByTxHash(ctx context.Context, txHash chainhash.Hash) (*wire.MsgTx, error) {
-	transaction, err := d.btcclient.GetRawTransaction(&txHash)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to get raw transaction")
-	}
-
-	return transaction.MsgTx(), nil
-}

modules/nodesale/api/httphandler/nodes.go

@@ -6,7 +6,6 @@ import (
 	"github.com/cockroachdb/errors"
 	"github.com/gaze-network/indexer-network/common/errs"
 	"github.com/gaze-network/indexer-network/modules/nodesale/datagateway"
-	"github.com/gaze-network/indexer-network/modules/nodesale/internal/entity"
 	"github.com/gofiber/fiber/v2"
 )
 
@@ -44,24 +43,15 @@ func (h *handler) nodesHandler(ctx *fiber.Ctx) error {
 		return errs.NewPublicError("Invalid deploy ID")
 	}
 
-	var nodes []entity.Node
-	if ownerPublicKey == "" {
-		nodes, err = h.nodeSaleDg.GetNodesByDeployment(ctx.UserContext(), blockHeight, txIndex)
-		if err != nil {
-			return errors.Wrap(err, "Can't get nodes from db")
-		}
-	} else {
-		nodes, err = h.nodeSaleDg.GetNodesByPubkey(ctx.UserContext(), datagateway.GetNodesByPubkeyParams{
-			SaleBlock:      blockHeight,
-			SaleTxIndex:    txIndex,
-			OwnerPublicKey: ownerPublicKey,
-			DelegatedTo:    delegateePublicKey,
-		})
-		if err != nil {
-			return errors.Wrap(err, "Can't get nodes from db")
-		}
+	nodes, err := h.nodeSaleDg.GetNodesByPubkey(ctx.UserContext(), datagateway.GetNodesByPubkeyParams{
+		SaleBlock:      blockHeight,
+		SaleTxIndex:    txIndex,
+		OwnerPublicKey: ownerPublicKey,
+		DelegatedTo:    delegateePublicKey,
+	})
+	if err != nil {
+		return errors.Wrap(err, "Can't get nodes from db")
 	}
-
 	responses := make([]nodeResponse, len(nodes))
 	for i, node := range nodes {
 		responses[i].DeployId = request.DeployId

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

@@ -48,10 +48,4 @@ LEFT JOIN
 		sale_tx_index= $2) 
 	AS nodes ON tiers.tier_index = nodes.tier_index 
 GROUP BY tiers.tier_index
-ORDER BY tiers.tier_index;
-
--- name: GetNodesByDeployment :many
-SELECT * 
-FROM nodes
-WHERE sale_block = $1 AND
-    sale_tx_index = $2;
+ORDER BY tiers.tier_index;

modules/nodesale/datagateway/mocks/NodeSaleDataGatewayWithTx.go

@@ -666,66 +666,6 @@ func (_c *NodeSaleDataGatewayWithTx_GetNodeSale_Call) RunAndReturn(run func(cont
 	return _c
 }
 
-// GetNodesByDeployment provides a mock function with given fields: ctx, saleBlock, saleTxIndex
-func (_m *NodeSaleDataGatewayWithTx) GetNodesByDeployment(ctx context.Context, saleBlock int64, saleTxIndex int32) ([]entity.Node, error) {
-	ret := _m.Called(ctx, saleBlock, saleTxIndex)
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetNodesByDeployment")
-	}
-
-	var r0 []entity.Node
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, int64, int32) ([]entity.Node, error)); ok {
-		return rf(ctx, saleBlock, saleTxIndex)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, int64, int32) []entity.Node); ok {
-		r0 = rf(ctx, saleBlock, saleTxIndex)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]entity.Node)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, int64, int32) error); ok {
-		r1 = rf(ctx, saleBlock, saleTxIndex)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// NodeSaleDataGatewayWithTx_GetNodesByDeployment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNodesByDeployment'
-type NodeSaleDataGatewayWithTx_GetNodesByDeployment_Call struct {
-	*mock.Call
-}
-
-// GetNodesByDeployment is a helper method to define mock.On call
-//   - ctx context.Context
-//   - saleBlock int64
-//   - saleTxIndex int32
-func (_e *NodeSaleDataGatewayWithTx_Expecter) GetNodesByDeployment(ctx interface{}, saleBlock interface{}, saleTxIndex interface{}) *NodeSaleDataGatewayWithTx_GetNodesByDeployment_Call {
-	return &NodeSaleDataGatewayWithTx_GetNodesByDeployment_Call{Call: _e.mock.On("GetNodesByDeployment", ctx, saleBlock, saleTxIndex)}
-}
-
-func (_c *NodeSaleDataGatewayWithTx_GetNodesByDeployment_Call) Run(run func(ctx context.Context, saleBlock int64, saleTxIndex int32)) *NodeSaleDataGatewayWithTx_GetNodesByDeployment_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(int64), args[2].(int32))
-	})
-	return _c
-}
-
-func (_c *NodeSaleDataGatewayWithTx_GetNodesByDeployment_Call) Return(_a0 []entity.Node, _a1 error) *NodeSaleDataGatewayWithTx_GetNodesByDeployment_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *NodeSaleDataGatewayWithTx_GetNodesByDeployment_Call) RunAndReturn(run func(context.Context, int64, int32) ([]entity.Node, error)) *NodeSaleDataGatewayWithTx_GetNodesByDeployment_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
 // GetNodesByIds provides a mock function with given fields: ctx, arg
 func (_m *NodeSaleDataGatewayWithTx) GetNodesByIds(ctx context.Context, arg datagateway.GetNodesByIdsParams) ([]entity.Node, error) {
 	ret := _m.Called(ctx, arg)

modules/nodesale/datagateway/nodesale.go

@@ -23,7 +23,6 @@ type NodeSaleDataGateway interface {
 	CreateNode(ctx context.Context, arg entity.Node) error
 	GetNodeCountByTierIndex(ctx context.Context, arg GetNodeCountByTierIndexParams) ([]GetNodeCountByTierIndexRow, error)
 	GetNodesByPubkey(ctx context.Context, arg GetNodesByPubkeyParams) ([]entity.Node, error)
-	GetNodesByDeployment(ctx context.Context, saleBlock int64, saleTxIndex int32) ([]entity.Node, error)
 	GetEventsByWallet(ctx context.Context, walletAddress string) ([]entity.NodeSaleEvent, error)
 }
 

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

@@ -103,47 +103,6 @@ func (q *Queries) GetNodeCountByTierIndex(ctx context.Context, arg GetNodeCountB
 	return items, nil
 }
 
-const getNodesByDeployment = `-- name: GetNodesByDeployment :many
-SELECT sale_block, sale_tx_index, node_id, tier_index, delegated_to, owner_public_key, purchase_tx_hash, delegate_tx_hash 
-FROM nodes
-WHERE sale_block = $1 AND
-    sale_tx_index = $2
-`
-
-type GetNodesByDeploymentParams struct {
-	SaleBlock   int64
-	SaleTxIndex int32
-}
-
-func (q *Queries) GetNodesByDeployment(ctx context.Context, arg GetNodesByDeploymentParams) ([]Node, error) {
-	rows, err := q.db.Query(ctx, getNodesByDeployment, arg.SaleBlock, arg.SaleTxIndex)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var items []Node
-	for rows.Next() {
-		var i Node
-		if err := rows.Scan(
-			&i.SaleBlock,
-			&i.SaleTxIndex,
-			&i.NodeID,
-			&i.TierIndex,
-			&i.DelegatedTo,
-			&i.OwnerPublicKey,
-			&i.PurchaseTxHash,
-			&i.DelegateTxHash,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
 const getNodesByIds = `-- name: GetNodesByIds :many
 SELECT sale_block, sale_tx_index, node_id, tier_index, delegated_to, owner_public_key, purchase_tx_hash, delegate_tx_hash
 FROM nodes

modules/nodesale/repository/postgres/repository.go

@@ -234,14 +234,3 @@ func (repo *Repository) GetEventsByWallet(ctx context.Context, walletAddress str
 	}
 	return mapNodeSalesEvents(events), nil
 }
-
-func (repo *Repository) GetNodesByDeployment(ctx context.Context, saleBlock int64, saleTxIndex int32) ([]entity.Node, error) {
-	nodes, err := repo.queries.GetNodesByDeployment(ctx, gen.GetNodesByDeploymentParams{
-		SaleBlock:   saleBlock,
-		SaleTxIndex: saleTxIndex,
-	})
-	if err != nil {
-		return nil, errors.Wrap(err, "cannot get nodes by deploy")
-	}
-	return mapNodes(nodes), nil
-}

modules/runes/api/httphandler/get_balances_by_address.go

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

modules/runes/api/httphandler/get_balances_by_address_batch.go

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

modules/runes/api/httphandler/get_holders.go

@@ -1,13 +1,10 @@
 package httphandler
 
 import (
-	"bytes"
 	"encoding/hex"
-	"slices"
 
 	"github.com/cockroachdb/errors"
 	"github.com/gaze-network/indexer-network/common/errs"
-	"github.com/gaze-network/indexer-network/modules/runes/internal/entity"
 	"github.com/gaze-network/indexer-network/modules/runes/runes"
 	"github.com/gaze-network/uint128"
 	"github.com/gofiber/fiber/v2"
@@ -17,26 +14,13 @@ import (
 type getHoldersRequest struct {
 	Id          string `params:"id"`
 	BlockHeight uint64 `query:"blockHeight"`
-	Limit       int32  `json:"limit"`
-	Offset      int32  `json:"offset"`
 }
 
-const (
-	getHoldersMaxLimit     = 1000
-	getHoldersDefaultLimit = 100
-)
-
 func (r getHoldersRequest) Validate() error {
 	var errList []error
 	if !isRuneIdOrRuneName(r.Id) {
 		errList = append(errList, errors.New("'id' is not valid rune id or rune name"))
 	}
-	if r.Limit < 0 {
-		errList = append(errList, errors.New("'limit' must be non-negative"))
-	}
-	if r.Limit > getHoldersMaxLimit {
-		errList = append(errList, errors.Errorf("'limit' cannot exceed %d", getHoldersMaxLimit))
-	}
 	return errs.WithPublicMessage(errors.Join(errList...), "validation error")
 }
 
@@ -77,10 +61,6 @@ func (h *HttpHandler) GetHolders(ctx *fiber.Ctx) (err error) {
 		blockHeight = uint64(blockHeader.Height)
 	}
 
-	if req.Limit == 0 {
-		req.Limit = getHoldersDefaultLimit
-	}
-
 	var runeId runes.RuneId
 	if req.Id != "" {
 		var ok bool
@@ -95,13 +75,10 @@ func (h *HttpHandler) GetHolders(ctx *fiber.Ctx) (err error) {
 		if errors.Is(err, errs.NotFound) {
 			return errs.NewPublicError("rune not found")
 		}
-		return errors.Wrap(err, "error during GetRuneEntryByRuneIdAndHeight")
+		return errors.Wrap(err, "error during GetHoldersByHeight")
 	}
-	holdingBalances, err := h.usecase.GetBalancesByRuneId(ctx.UserContext(), runeId, blockHeight, req.Limit, req.Offset)
+	holdingBalances, err := h.usecase.GetBalancesByRuneId(ctx.UserContext(), runeId, blockHeight)
 	if err != nil {
-		if errors.Is(err, errs.NotFound) {
-			return errs.NewPublicError("balances not found")
-		}
 		return errors.Wrap(err, "error during GetBalancesByRuneId")
 	}
 
@@ -127,14 +104,6 @@ func (h *HttpHandler) GetHolders(ctx *fiber.Ctx) (err error) {
 		})
 	}
 
-	// sort by amount descending, then pk script ascending
-	slices.SortFunc(holdingBalances, func(b1, b2 *entity.Balance) int {
-		if b1.Amount.Cmp(b2.Amount) == 0 {
-			return bytes.Compare(b1.PkScript, b2.PkScript)
-		}
-		return b2.Amount.Cmp(b1.Amount)
-	})
-
 	resp := getHoldersResponse{
 		Result: &getHoldersResult{
 			BlockHeight:  blockHeight,

modules/runes/api/httphandler/get_token_info.go

@@ -83,9 +83,6 @@ func (h *HttpHandler) GetTokenInfo(ctx *fiber.Ctx) (err error) {
 	if blockHeight == 0 {
 		blockHeader, err := h.usecase.GetLatestBlock(ctx.UserContext())
 		if err != nil {
-			if errors.Is(err, errs.NotFound) {
-				return errs.NewPublicError("latest block not found")
-			}
 			return errors.Wrap(err, "error during GetLatestBlock")
 		}
 		blockHeight = uint64(blockHeader.Height)
@@ -107,11 +104,8 @@ func (h *HttpHandler) GetTokenInfo(ctx *fiber.Ctx) (err error) {
 		}
 		return errors.Wrap(err, "error during GetTokenInfoByHeight")
 	}
-	holdingBalances, err := h.usecase.GetBalancesByRuneId(ctx.UserContext(), runeId, blockHeight, -1, 0) // get all balances
+	holdingBalances, err := h.usecase.GetBalancesByRuneId(ctx.UserContext(), runeId, blockHeight)
 	if err != nil {
-		if errors.Is(err, errs.NotFound) {
-			return errs.NewPublicError("rune not found")
-		}
 		return errors.Wrap(err, "error during GetBalancesByRuneId")
 	}
 

modules/runes/api/httphandler/get_transactions.go

@@ -1,7 +1,6 @@
 package httphandler
 
 import (
-	"cmp"
 	"encoding/hex"
 	"fmt"
 	"slices"
@@ -16,18 +15,12 @@ import (
 )
 
 type getTransactionsRequest struct {
-	Wallet    string `query:"wallet"`
-	Id        string `query:"id"`
-	FromBlock int64  `query:"fromBlock"`
-	ToBlock   int64  `query:"toBlock"`
-	Limit     int32  `query:"limit"`
-	Offset    int32  `query:"offset"`
-}
+	Wallet string `query:"wallet"`
+	Id     string `query:"id"`
 
-const (
-	getTransactionsMaxLimit     = 3000
-	getTransactionsDefaultLimit = 100
-)
+	FromBlock int64 `query:"fromBlock"`
+	ToBlock   int64 `query:"toBlock"`
+}
 
 func (r getTransactionsRequest) Validate() error {
 	var errList []error
@@ -40,12 +33,6 @@ func (r getTransactionsRequest) Validate() error {
 	if r.ToBlock < -1 {
 		errList = append(errList, errors.Errorf("invalid toBlock range"))
 	}
-	if r.Limit < 0 {
-		errList = append(errList, errors.New("'limit' must be non-negative"))
-	}
-	if r.Limit > getTransactionsMaxLimit {
-		errList = append(errList, errors.Errorf("'limit' cannot exceed %d", getTransactionsMaxLimit))
-	}
 	return errs.WithPublicMessage(errors.Join(errList...), "validation error")
 }
 
@@ -146,9 +133,6 @@ func (h *HttpHandler) GetTransactions(ctx *fiber.Ctx) (err error) {
 			return errs.NewPublicError("unable to resolve rune id from \"id\"")
 		}
 	}
-	if req.Limit == 0 {
-		req.Limit = getTransactionsDefaultLimit
-	}
 
 	// default to latest block
 	if req.ToBlock == 0 {
@@ -159,9 +143,6 @@ func (h *HttpHandler) GetTransactions(ctx *fiber.Ctx) (err error) {
 	if req.FromBlock == -1 || req.ToBlock == -1 {
 		blockHeader, err := h.usecase.GetLatestBlock(ctx.UserContext())
 		if err != nil {
-			if errors.Is(err, errs.NotFound) {
-				return errs.NewPublicError("latest block not found")
-			}
 			return errors.Wrap(err, "error during GetLatestBlock")
 		}
 		if req.FromBlock == -1 {
@@ -177,11 +158,8 @@ func (h *HttpHandler) GetTransactions(ctx *fiber.Ctx) (err error) {
 		return errs.NewPublicError(fmt.Sprintf("fromBlock must be less than or equal to toBlock, got fromBlock=%d, toBlock=%d", req.FromBlock, req.ToBlock))
 	}
 
-	txs, err := h.usecase.GetRuneTransactions(ctx.UserContext(), pkScript, runeId, uint64(req.FromBlock), uint64(req.ToBlock), req.Limit, req.Offset)
+	txs, err := h.usecase.GetRuneTransactions(ctx.UserContext(), pkScript, runeId, uint64(req.FromBlock), uint64(req.ToBlock))
 	if err != nil {
-		if errors.Is(err, errs.NotFound) {
-			return errs.NewPublicError("transactions not found")
-		}
 		return errors.Wrap(err, "error during GetRuneTransactions")
 	}
 
@@ -203,9 +181,6 @@ func (h *HttpHandler) GetTransactions(ctx *fiber.Ctx) (err error) {
 	allRuneIds = lo.Uniq(allRuneIds)
 	runeEntries, err := h.usecase.GetRuneEntryByRuneIdBatch(ctx.UserContext(), allRuneIds)
 	if err != nil {
-		if errors.Is(err, errs.NotFound) {
-			return errs.NewPublicError("rune entries not found")
-		}
 		return errors.Wrap(err, "error during GetRuneEntryByRuneIdBatch")
 	}
 
@@ -304,12 +279,12 @@ func (h *HttpHandler) GetTransactions(ctx *fiber.Ctx) (err error) {
 		}
 		txList = append(txList, respTx)
 	}
-	// sort by block height DESC, then index DESC
+	// sort by block height ASC, then index ASC
 	slices.SortFunc(txList, func(t1, t2 transaction) int {
 		if t1.BlockHeight != t2.BlockHeight {
-			return cmp.Compare(t2.BlockHeight, t1.BlockHeight)
+			return int(t1.BlockHeight - t2.BlockHeight)
 		}
-		return cmp.Compare(t2.Index, t1.Index)
+		return int(t1.Index - t2.Index)
 	})
 
 	resp := getTransactionsResponse{

modules/runes/api/httphandler/get_utxos_by_address.go

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

modules/runes/api/httphandler/get_utxos_output_by_location.go

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

modules/runes/api/httphandler/get_utxos_output_by_location_batch.go

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

modules/runes/api/httphandler/routes.go

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

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

@@ -118,7 +118,5 @@ CREATE TABLE IF NOT EXISTS "runes_balances" (
 	"amount" DECIMAL NOT NULL,
 	PRIMARY KEY ("pkscript", "rune_id", "block_height")
 );
-CREATE INDEX IF NOT EXISTS runes_balances_rune_id_block_height_idx ON "runes_balances" USING BTREE ("rune_id", "block_height");
-CREATE INDEX IF NOT EXISTS runes_balances_pkscript_block_height_idx ON "runes_balances" USING BTREE ("pkscript", "block_height");
 
 COMMIT;

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

@@ -2,13 +2,13 @@
 WITH balances AS (
   SELECT DISTINCT ON (rune_id) * FROM runes_balances WHERE pkscript = $1 AND block_height <= $2 ORDER BY rune_id, block_height DESC
 )
-SELECT * FROM balances WHERE amount > 0 ORDER BY amount DESC, rune_id LIMIT $3 OFFSET $4;
+SELECT * FROM balances WHERE amount > 0;
 
 -- name: GetBalancesByRuneId :many
 WITH balances AS (
   SELECT DISTINCT ON (pkscript) * FROM runes_balances WHERE rune_id = $1 AND block_height <= $2 ORDER BY pkscript, block_height DESC
 )
-SELECT * FROM balances WHERE amount > 0 ORDER BY amount DESC, pkscript LIMIT $3 OFFSET $4;
+SELECT * FROM balances WHERE amount > 0;
 
 -- name: GetBalanceByPkScriptAndRuneId :one
 SELECT * FROM runes_balances WHERE pkscript = $1 AND rune_id = $2 AND block_height <= $3 ORDER BY block_height DESC LIMIT 1;
@@ -16,28 +16,8 @@ SELECT * FROM runes_balances WHERE pkscript = $1 AND rune_id = $2 AND block_heig
 -- name: GetOutPointBalancesAtOutPoint :many
 SELECT * FROM runes_outpoint_balances WHERE tx_hash = $1 AND tx_idx = $2;
 
--- name: GetRunesUTXOsByPkScript :many
-SELECT tx_hash, tx_idx, max("pkscript") as pkscript, array_agg("rune_id") as rune_ids, array_agg("amount") as amounts 
-  FROM runes_outpoint_balances 
-  WHERE
-    pkscript = @pkScript AND
-    block_height <= @block_height AND
-    (spent_height IS NULL OR spent_height > @block_height)
-  GROUP BY tx_hash, tx_idx
-  ORDER BY tx_hash, tx_idx 
-  LIMIT $1 OFFSET $2;
-
--- name: GetRunesUTXOsByRuneIdAndPkScript :many
-SELECT tx_hash, tx_idx, max("pkscript") as pkscript, array_agg("rune_id") as rune_ids, array_agg("amount") as amounts 
-  FROM runes_outpoint_balances 
-  WHERE
-    pkscript = @pkScript AND 
-    block_height <= @block_height AND 
-    (spent_height IS NULL OR spent_height > @block_height)
-  GROUP BY tx_hash, tx_idx
-  HAVING array_agg("rune_id") @> @rune_ids::text[] 
-  ORDER BY tx_hash, tx_idx 
-  LIMIT $1 OFFSET $2;
+-- name: GetUnspentOutPointBalancesByPkScript :many
+SELECT * FROM runes_outpoint_balances WHERE pkscript = @pkScript AND block_height <= @block_height AND (spent_height IS NULL OR spent_height > @block_height);
 
 -- name: GetRuneEntriesByRuneIds :many
 WITH states AS (
@@ -77,12 +57,7 @@ SELECT * FROM runes_transactions
   ) AND (
     @from_block <= runes_transactions.block_height AND runes_transactions.block_height <= @to_block
   )
-ORDER BY runes_transactions.block_height DESC, runes_transactions.index DESC LIMIT $1 OFFSET $2;
-
--- name: GetRuneTransaction :one
-SELECT * FROM runes_transactions
-  LEFT JOIN runes_runestones ON runes_transactions.hash = runes_runestones.tx_hash
-  WHERE hash = $1 LIMIT 1;
+ORDER BY runes_transactions.block_height DESC LIMIT 10000;
 
 -- name: CountRuneEntries :one
 SELECT COUNT(*) FROM runes_entries;

modules/runes/datagateway/runes.go

@@ -3,7 +3,6 @@ package datagateway
 import (
 	"context"
 
-	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/gaze-network/indexer-network/core/types"
 	"github.com/gaze-network/indexer-network/modules/runes/internal/entity"
@@ -28,12 +27,10 @@ type RunesReaderDataGateway interface {
 	GetLatestBlock(ctx context.Context) (types.BlockHeader, error)
 	GetIndexedBlockByHeight(ctx context.Context, height int64) (*entity.IndexedBlock, error)
 	// GetRuneTransactions returns the runes transactions, filterable by pkScript, runeId and height. If pkScript, runeId or height is zero value, that filter is ignored.
-	GetRuneTransactions(ctx context.Context, pkScript []byte, runeId runes.RuneId, fromBlock, toBlock uint64, limit int32, offset int32) ([]*entity.RuneTransaction, error)
-	GetRuneTransaction(ctx context.Context, txHash chainhash.Hash) (*entity.RuneTransaction, error)
+	GetRuneTransactions(ctx context.Context, pkScript []byte, runeId runes.RuneId, fromBlock, toBlock uint64) ([]*entity.RuneTransaction, error)
 
 	GetRunesBalancesAtOutPoint(ctx context.Context, outPoint wire.OutPoint) (map[runes.RuneId]*entity.OutPointBalance, error)
-	GetRunesUTXOsByRuneIdAndPkScript(ctx context.Context, runeId runes.RuneId, pkScript []byte, blockHeight uint64, limit int32, offset int32) ([]*entity.RunesUTXO, error)
-	GetRunesUTXOsByPkScript(ctx context.Context, pkScript []byte, blockHeight uint64, limit int32, offset int32) ([]*entity.RunesUTXO, error)
+	GetUnspentOutPointBalancesByPkScript(ctx context.Context, pkScript []byte, blockHeight uint64) ([]*entity.OutPointBalance, error)
 	// GetRuneIdFromRune returns the RuneId for the given rune. Returns errs.NotFound if the rune entry is not found.
 	GetRuneIdFromRune(ctx context.Context, rune runes.Rune) (runes.RuneId, error)
 	// GetRuneEntryByRuneId returns the RuneEntry for the given runeId. Returns errs.NotFound if the rune entry is not found.
@@ -48,12 +45,10 @@ type RunesReaderDataGateway interface {
 	CountRuneEntries(ctx context.Context) (uint64, error)
 
 	// GetBalancesByPkScript returns the balances for the given pkScript at the given blockHeight.
-	// Use limit = -1 as no limit.
-	GetBalancesByPkScript(ctx context.Context, pkScript []byte, blockHeight uint64, limit int32, offset int32) ([]*entity.Balance, error)
+	GetBalancesByPkScript(ctx context.Context, pkScript []byte, blockHeight uint64) (map[runes.RuneId]*entity.Balance, error)
 	// GetBalancesByRuneId returns the balances for the given runeId at the given blockHeight.
 	// Cannot use []byte as map key, so we're returning as slice.
-	// Use limit = -1 as no limit.
-	GetBalancesByRuneId(ctx context.Context, runeId runes.RuneId, blockHeight uint64, limit int32, offset int32) ([]*entity.Balance, error)
+	GetBalancesByRuneId(ctx context.Context, runeId runes.RuneId, blockHeight uint64) ([]*entity.Balance, error)
 	// GetBalancesByPkScriptAndRuneId returns the balance for the given pkScript and runeId at the given blockHeight.
 	GetBalanceByPkScriptAndRuneId(ctx context.Context, pkScript []byte, runeId runes.RuneId, blockHeight uint64) (*entity.Balance, error)
 }

modules/runes/internal/entity/runes_utxo.go

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

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

@@ -296,14 +296,12 @@ const getBalancesByPkScript = `-- name: GetBalancesByPkScript :many
 WITH balances AS (
   SELECT DISTINCT ON (rune_id) pkscript, block_height, rune_id, amount FROM runes_balances WHERE pkscript = $1 AND block_height <= $2 ORDER BY rune_id, block_height DESC
 )
-SELECT pkscript, block_height, rune_id, amount FROM balances WHERE amount > 0 ORDER BY amount DESC, rune_id LIMIT $3 OFFSET $4
+SELECT pkscript, block_height, rune_id, amount FROM balances WHERE amount > 0
 `
 
 type GetBalancesByPkScriptParams struct {
 	Pkscript    string
 	BlockHeight int32
-	Limit       int32
-	Offset      int32
 }
 
 type GetBalancesByPkScriptRow struct {
@@ -314,12 +312,7 @@ type GetBalancesByPkScriptRow struct {
 }
 
 func (q *Queries) GetBalancesByPkScript(ctx context.Context, arg GetBalancesByPkScriptParams) ([]GetBalancesByPkScriptRow, error) {
-	rows, err := q.db.Query(ctx, getBalancesByPkScript,
-		arg.Pkscript,
-		arg.BlockHeight,
-		arg.Limit,
-		arg.Offset,
-	)
+	rows, err := q.db.Query(ctx, getBalancesByPkScript, arg.Pkscript, arg.BlockHeight)
 	if err != nil {
 		return nil, err
 	}
@@ -347,14 +340,12 @@ const getBalancesByRuneId = `-- name: GetBalancesByRuneId :many
 WITH balances AS (
   SELECT DISTINCT ON (pkscript) pkscript, block_height, rune_id, amount FROM runes_balances WHERE rune_id = $1 AND block_height <= $2 ORDER BY pkscript, block_height DESC
 )
-SELECT pkscript, block_height, rune_id, amount FROM balances WHERE amount > 0 ORDER BY amount DESC, pkscript LIMIT $3 OFFSET $4
+SELECT pkscript, block_height, rune_id, amount FROM balances WHERE amount > 0
 `
 
 type GetBalancesByRuneIdParams struct {
 	RuneID      string
 	BlockHeight int32
-	Limit       int32
-	Offset      int32
 }
 
 type GetBalancesByRuneIdRow struct {
@@ -365,12 +356,7 @@ type GetBalancesByRuneIdRow struct {
 }
 
 func (q *Queries) GetBalancesByRuneId(ctx context.Context, arg GetBalancesByRuneIdParams) ([]GetBalancesByRuneIdRow, error) {
-	rows, err := q.db.Query(ctx, getBalancesByRuneId,
-		arg.RuneID,
-		arg.BlockHeight,
-		arg.Limit,
-		arg.Offset,
-	)
+	rows, err := q.db.Query(ctx, getBalancesByRuneId, arg.RuneID, arg.BlockHeight)
 	if err != nil {
 		return nil, err
 	}
@@ -645,106 +631,27 @@ func (q *Queries) GetRuneIdFromRune(ctx context.Context, rune string) (string, e
 	return rune_id, err
 }
 
-const getRuneTransaction = `-- name: GetRuneTransaction :one
-SELECT hash, runes_transactions.block_height, index, timestamp, inputs, outputs, mints, burns, rune_etched, tx_hash, runes_runestones.block_height, etching, etching_divisibility, etching_premine, etching_rune, etching_spacers, etching_symbol, etching_terms, etching_terms_amount, etching_terms_cap, etching_terms_height_start, etching_terms_height_end, etching_terms_offset_start, etching_terms_offset_end, etching_turbo, edicts, mint, pointer, cenotaph, flaws FROM runes_transactions
-  LEFT JOIN runes_runestones ON runes_transactions.hash = runes_runestones.tx_hash
-  WHERE hash = $1 LIMIT 1
-`
-
-type GetRuneTransactionRow struct {
-	Hash                    string
-	BlockHeight             int32
-	Index                   int32
-	Timestamp               pgtype.Timestamp
-	Inputs                  []byte
-	Outputs                 []byte
-	Mints                   []byte
-	Burns                   []byte
-	RuneEtched              bool
-	TxHash                  pgtype.Text
-	BlockHeight_2           pgtype.Int4
-	Etching                 pgtype.Bool
-	EtchingDivisibility     pgtype.Int2
-	EtchingPremine          pgtype.Numeric
-	EtchingRune             pgtype.Text
-	EtchingSpacers          pgtype.Int4
-	EtchingSymbol           pgtype.Int4
-	EtchingTerms            pgtype.Bool
-	EtchingTermsAmount      pgtype.Numeric
-	EtchingTermsCap         pgtype.Numeric
-	EtchingTermsHeightStart pgtype.Int4
-	EtchingTermsHeightEnd   pgtype.Int4
-	EtchingTermsOffsetStart pgtype.Int4
-	EtchingTermsOffsetEnd   pgtype.Int4
-	EtchingTurbo            pgtype.Bool
-	Edicts                  []byte
-	Mint                    pgtype.Text
-	Pointer                 pgtype.Int4
-	Cenotaph                pgtype.Bool
-	Flaws                   pgtype.Int4
-}
-
-func (q *Queries) GetRuneTransaction(ctx context.Context, hash string) (GetRuneTransactionRow, error) {
-	row := q.db.QueryRow(ctx, getRuneTransaction, hash)
-	var i GetRuneTransactionRow
-	err := row.Scan(
-		&i.Hash,
-		&i.BlockHeight,
-		&i.Index,
-		&i.Timestamp,
-		&i.Inputs,
-		&i.Outputs,
-		&i.Mints,
-		&i.Burns,
-		&i.RuneEtched,
-		&i.TxHash,
-		&i.BlockHeight_2,
-		&i.Etching,
-		&i.EtchingDivisibility,
-		&i.EtchingPremine,
-		&i.EtchingRune,
-		&i.EtchingSpacers,
-		&i.EtchingSymbol,
-		&i.EtchingTerms,
-		&i.EtchingTermsAmount,
-		&i.EtchingTermsCap,
-		&i.EtchingTermsHeightStart,
-		&i.EtchingTermsHeightEnd,
-		&i.EtchingTermsOffsetStart,
-		&i.EtchingTermsOffsetEnd,
-		&i.EtchingTurbo,
-		&i.Edicts,
-		&i.Mint,
-		&i.Pointer,
-		&i.Cenotaph,
-		&i.Flaws,
-	)
-	return i, err
-}
-
 const getRuneTransactions = `-- name: GetRuneTransactions :many
 SELECT hash, runes_transactions.block_height, index, timestamp, inputs, outputs, mints, burns, rune_etched, tx_hash, runes_runestones.block_height, etching, etching_divisibility, etching_premine, etching_rune, etching_spacers, etching_symbol, etching_terms, etching_terms_amount, etching_terms_cap, etching_terms_height_start, etching_terms_height_end, etching_terms_offset_start, etching_terms_offset_end, etching_turbo, edicts, mint, pointer, cenotaph, flaws FROM runes_transactions
 	LEFT JOIN runes_runestones ON runes_transactions.hash = runes_runestones.tx_hash
 	WHERE (
-    $3::BOOLEAN = FALSE -- if @filter_pk_script is TRUE, apply pk_script filter
+    $1::BOOLEAN = FALSE -- if @filter_pk_script is TRUE, apply pk_script filter
+    OR runes_transactions.outputs @> $2::JSONB 
+    OR runes_transactions.inputs @> $2::JSONB
+  ) AND (
+    $3::BOOLEAN = FALSE -- if @filter_rune_id is TRUE, apply rune_id filter
     OR runes_transactions.outputs @> $4::JSONB 
-    OR runes_transactions.inputs @> $4::JSONB
+    OR runes_transactions.inputs @> $4::JSONB 
+    OR runes_transactions.mints ? $5 
+    OR runes_transactions.burns ? $5
+    OR (runes_transactions.rune_etched = TRUE AND runes_transactions.block_height = $6 AND runes_transactions.index = $7)
   ) AND (
-    $5::BOOLEAN = FALSE -- if @filter_rune_id is TRUE, apply rune_id filter
-    OR runes_transactions.outputs @> $6::JSONB 
-    OR runes_transactions.inputs @> $6::JSONB 
-    OR runes_transactions.mints ? $7 
-    OR runes_transactions.burns ? $7
-    OR (runes_transactions.rune_etched = TRUE AND runes_transactions.block_height = $8 AND runes_transactions.index = $9)
-  ) AND (
-    $10 <= runes_transactions.block_height AND runes_transactions.block_height <= $11
+    $8 <= runes_transactions.block_height AND runes_transactions.block_height <= $9
   )
-ORDER BY runes_transactions.block_height DESC, runes_transactions.index DESC LIMIT $1 OFFSET $2
+ORDER BY runes_transactions.block_height DESC LIMIT 10000
 `
 
 type GetRuneTransactionsParams struct {
-	Limit             int32
-	Offset            int32
 	FilterPkScript    bool
 	PkScriptParam     []byte
 	FilterRuneID      bool
@@ -791,8 +698,6 @@ type GetRuneTransactionsRow struct {
 
 func (q *Queries) GetRuneTransactions(ctx context.Context, arg GetRuneTransactionsParams) ([]GetRuneTransactionsRow, error) {
 	rows, err := q.db.Query(ctx, getRuneTransactions,
-		arg.Limit,
-		arg.Offset,
 		arg.FilterPkScript,
 		arg.PkScriptParam,
 		arg.FilterRuneID,
@@ -852,114 +757,32 @@ func (q *Queries) GetRuneTransactions(ctx context.Context, arg GetRuneTransactio
 	return items, nil
 }
 
-const getRunesUTXOsByPkScript = `-- name: GetRunesUTXOsByPkScript :many
-SELECT tx_hash, tx_idx, max("pkscript") as pkscript, array_agg("rune_id") as rune_ids, array_agg("amount") as amounts 
-  FROM runes_outpoint_balances 
-  WHERE
-    pkscript = $3 AND
-    block_height <= $4 AND
-    (spent_height IS NULL OR spent_height > $4)
-  GROUP BY tx_hash, tx_idx
-  ORDER BY tx_hash, tx_idx 
-  LIMIT $1 OFFSET $2
+const getUnspentOutPointBalancesByPkScript = `-- name: GetUnspentOutPointBalancesByPkScript :many
+SELECT rune_id, pkscript, tx_hash, tx_idx, amount, block_height, spent_height FROM runes_outpoint_balances WHERE pkscript = $1 AND block_height <= $2 AND (spent_height IS NULL OR spent_height > $2)
 `
 
-type GetRunesUTXOsByPkScriptParams struct {
-	Limit       int32
-	Offset      int32
+type GetUnspentOutPointBalancesByPkScriptParams struct {
 	Pkscript    string
 	BlockHeight int32
 }
 
-type GetRunesUTXOsByPkScriptRow struct {
-	TxHash   string
-	TxIdx    int32
-	Pkscript interface{}
-	RuneIds  interface{}
-	Amounts  interface{}
-}
-
-func (q *Queries) GetRunesUTXOsByPkScript(ctx context.Context, arg GetRunesUTXOsByPkScriptParams) ([]GetRunesUTXOsByPkScriptRow, error) {
-	rows, err := q.db.Query(ctx, getRunesUTXOsByPkScript,
-		arg.Limit,
-		arg.Offset,
-		arg.Pkscript,
-		arg.BlockHeight,
-	)
+func (q *Queries) GetUnspentOutPointBalancesByPkScript(ctx context.Context, arg GetUnspentOutPointBalancesByPkScriptParams) ([]RunesOutpointBalance, error) {
+	rows, err := q.db.Query(ctx, getUnspentOutPointBalancesByPkScript, arg.Pkscript, arg.BlockHeight)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-	var items []GetRunesUTXOsByPkScriptRow
+	var items []RunesOutpointBalance
 	for rows.Next() {
-		var i GetRunesUTXOsByPkScriptRow
+		var i RunesOutpointBalance
 		if err := rows.Scan(
+			&i.RuneID,
+			&i.Pkscript,
 			&i.TxHash,
 			&i.TxIdx,
-			&i.Pkscript,
-			&i.RuneIds,
-			&i.Amounts,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const getRunesUTXOsByRuneIdAndPkScript = `-- name: GetRunesUTXOsByRuneIdAndPkScript :many
-SELECT tx_hash, tx_idx, max("pkscript") as pkscript, array_agg("rune_id") as rune_ids, array_agg("amount") as amounts 
-  FROM runes_outpoint_balances 
-  WHERE
-    pkscript = $3 AND 
-    block_height <= $4 AND 
-    (spent_height IS NULL OR spent_height > $4)
-  GROUP BY tx_hash, tx_idx
-  HAVING array_agg("rune_id") @> $5::text[] 
-  ORDER BY tx_hash, tx_idx 
-  LIMIT $1 OFFSET $2
-`
-
-type GetRunesUTXOsByRuneIdAndPkScriptParams struct {
-	Limit       int32
-	Offset      int32
-	Pkscript    string
-	BlockHeight int32
-	RuneIds     []string
-}
-
-type GetRunesUTXOsByRuneIdAndPkScriptRow struct {
-	TxHash   string
-	TxIdx    int32
-	Pkscript interface{}
-	RuneIds  interface{}
-	Amounts  interface{}
-}
-
-func (q *Queries) GetRunesUTXOsByRuneIdAndPkScript(ctx context.Context, arg GetRunesUTXOsByRuneIdAndPkScriptParams) ([]GetRunesUTXOsByRuneIdAndPkScriptRow, error) {
-	rows, err := q.db.Query(ctx, getRunesUTXOsByRuneIdAndPkScript,
-		arg.Limit,
-		arg.Offset,
-		arg.Pkscript,
-		arg.BlockHeight,
-		arg.RuneIds,
-	)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var items []GetRunesUTXOsByRuneIdAndPkScriptRow
-	for rows.Next() {
-		var i GetRunesUTXOsByRuneIdAndPkScriptRow
-		if err := rows.Scan(
-			&i.TxHash,
-			&i.TxIdx,
-			&i.Pkscript,
-			&i.RuneIds,
-			&i.Amounts,
+			&i.Amount,
+			&i.BlockHeight,
+			&i.SpentHeight,
 		); err != nil {
 			return nil, err
 		}

modules/runes/repository/postgres/mapper.go

@@ -638,72 +638,6 @@ func mapIndexedBlockTypeToParams(src entity.IndexedBlock) (gen.CreateIndexedBloc
 	}, nil
 }
 
-func mapRunesUTXOModelToType(src gen.GetRunesUTXOsByPkScriptRow) (entity.RunesUTXO, error) {
-	pkScriptRaw, ok := src.Pkscript.(string)
-	if !ok {
-		return entity.RunesUTXO{}, errors.New("pkscript from database is not string")
-	}
-	pkScript, err := hex.DecodeString(pkScriptRaw)
-	if err != nil {
-		return entity.RunesUTXO{}, errors.Wrap(err, "failed to parse pkscript")
-	}
-	txHash, err := chainhash.NewHashFromStr(src.TxHash)
-	if err != nil {
-		return entity.RunesUTXO{}, errors.Wrap(err, "failed to parse tx hash")
-	}
-	runeIdsRaw, ok := src.RuneIds.([]interface{})
-	if !ok {
-		return entity.RunesUTXO{}, errors.New("src.RuneIds is not a slice")
-	}
-	runeIds := make([]string, 0, len(runeIdsRaw))
-	for i, raw := range runeIdsRaw {
-		runeId, ok := raw.(string)
-		if !ok {
-			return entity.RunesUTXO{}, errors.Errorf("src.RuneIds[%d] is not a string", i)
-		}
-		runeIds = append(runeIds, runeId)
-	}
-	amountsRaw, ok := src.Amounts.([]interface{})
-	if !ok {
-		return entity.RunesUTXO{}, errors.New("amounts from database is not a slice")
-	}
-	amounts := make([]pgtype.Numeric, 0, len(amountsRaw))
-	for i, raw := range amountsRaw {
-		amount, ok := raw.(pgtype.Numeric)
-		if !ok {
-			return entity.RunesUTXO{}, errors.Errorf("src.Amounts[%d] is not pgtype.Numeric", i)
-		}
-		amounts = append(amounts, amount)
-	}
-	if len(runeIds) != len(amounts) {
-		return entity.RunesUTXO{}, errors.New("rune ids and amounts have different lengths")
-	}
-
-	runesBalances := make([]entity.RunesUTXOBalance, 0, len(runeIds))
-	for i := range runeIds {
-		runeId, err := runes.NewRuneIdFromString(runeIds[i])
-		if err != nil {
-			return entity.RunesUTXO{}, errors.Wrap(err, "failed to parse rune id")
-		}
-		amount, err := uint128FromNumeric(amounts[i])
-		if err != nil {
-			return entity.RunesUTXO{}, errors.Wrap(err, "failed to parse amount")
-		}
-		runesBalances = append(runesBalances, entity.RunesUTXOBalance{
-			RuneId: runeId,
-			Amount: lo.FromPtr(amount),
-		})
-	}
-	return entity.RunesUTXO{
-		PkScript: pkScript,
-		OutPoint: wire.OutPoint{
-			Hash:  *txHash,
-			Index: uint32(src.TxIdx),
-		},
-		RuneBalances: runesBalances,
-	}, nil
-}
-
 func mapOutPointBalanceModelToType(src gen.RunesOutpointBalance) (entity.OutPointBalance, error) {
 	runeId, err := runes.NewRuneIdFromString(src.RuneID)
 	if err != nil {

modules/runes/repository/postgres/runes.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/hex"
 	"fmt"
-	"math"
 
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/wire"
@@ -63,18 +62,7 @@ func (r *Repository) GetIndexedBlockByHeight(ctx context.Context, height int64)
 	return indexedBlock, nil
 }
 
-const maxRuneTransactionsLimit = 10000 // temporary limit to prevent large queries from overwhelming the database
-
-func (r *Repository) GetRuneTransactions(ctx context.Context, pkScript []byte, runeId runes.RuneId, fromBlock, toBlock uint64, limit int32, offset int32) ([]*entity.RuneTransaction, error) {
-	if limit == -1 {
-		limit = maxRuneTransactionsLimit
-	}
-	if limit < 0 {
-		return nil, errors.Wrap(errs.InvalidArgument, "limit must be -1 or non-negative")
-	}
-	if limit > maxRuneTransactionsLimit {
-		return nil, errors.Wrapf(errs.InvalidArgument, "limit cannot exceed %d", maxRuneTransactionsLimit)
-	}
+func (r *Repository) GetRuneTransactions(ctx context.Context, pkScript []byte, runeId runes.RuneId, fromBlock, toBlock uint64) ([]*entity.RuneTransaction, error) {
 	pkScriptParam := []byte(fmt.Sprintf(`[{"pkScript":"%s"}]`, hex.EncodeToString(pkScript)))
 	runeIdParam := []byte(fmt.Sprintf(`[{"runeId":"%s"}]`, runeId.String()))
 	rows, err := r.queries.GetRuneTransactions(ctx, gen.GetRuneTransactionsParams{
@@ -89,9 +77,6 @@ func (r *Repository) GetRuneTransactions(ctx context.Context, pkScript []byte, r
 
 		FromBlock: int32(fromBlock),
 		ToBlock:   int32(toBlock),
-
-		Limit:  limit,
-		Offset: offset,
 	})
 	if err != nil {
 		return nil, errors.Wrap(err, "error during query")
@@ -120,33 +105,6 @@ func (r *Repository) GetRuneTransactions(ctx context.Context, pkScript []byte, r
 	return runeTxs, nil
 }
 
-func (r *Repository) GetRuneTransaction(ctx context.Context, txHash chainhash.Hash) (*entity.RuneTransaction, error) {
-	row, err := r.queries.GetRuneTransaction(ctx, txHash.String())
-	if errors.Is(err, pgx.ErrNoRows) {
-		return nil, errors.WithStack(errs.NotFound)
-	}
-
-	runeTxModel, runestoneModel, err := extractModelRuneTxAndRunestone(gen.GetRuneTransactionsRow(row))
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to extract rune transaction and runestone from row")
-	}
-
-	runeTx, err := mapRuneTransactionModelToType(runeTxModel)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to parse rune transaction model")
-	}
-
-	if runestoneModel != nil {
-		runestone, err := mapRunestoneModelToType(*runestoneModel)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to parse runestone model")
-		}
-		runeTx.Runestone = &runestone
-	}
-
-	return &runeTx, nil
-}
-
 func (r *Repository) GetRunesBalancesAtOutPoint(ctx context.Context, outPoint wire.OutPoint) (map[runes.RuneId]*entity.OutPointBalance, error) {
 	balances, err := r.queries.GetOutPointBalancesAtOutPoint(ctx, gen.GetOutPointBalancesAtOutPointParams{
 		TxHash: outPoint.Hash.String(),
@@ -167,59 +125,22 @@ func (r *Repository) GetRunesBalancesAtOutPoint(ctx context.Context, outPoint wi
 	return result, nil
 }
 
-func (r *Repository) GetRunesUTXOsByPkScript(ctx context.Context, pkScript []byte, blockHeight uint64, limit int32, offset int32) ([]*entity.RunesUTXO, error) {
-	if limit == -1 {
-		limit = math.MaxInt32
-	}
-	if limit < 0 {
-		return nil, errors.Wrap(errs.InvalidArgument, "limit must be -1 or non-negative")
-	}
-	rows, err := r.queries.GetRunesUTXOsByPkScript(ctx, gen.GetRunesUTXOsByPkScriptParams{
+func (r *Repository) GetUnspentOutPointBalancesByPkScript(ctx context.Context, pkScript []byte, blockHeight uint64) ([]*entity.OutPointBalance, error) {
+	balances, err := r.queries.GetUnspentOutPointBalancesByPkScript(ctx, gen.GetUnspentOutPointBalancesByPkScriptParams{
 		Pkscript:    hex.EncodeToString(pkScript),
 		BlockHeight: int32(blockHeight),
-		Limit:       limit,
-		Offset:      offset,
 	})
 	if err != nil {
 		return nil, errors.Wrap(err, "error during query")
 	}
 
-	result := make([]*entity.RunesUTXO, 0, len(rows))
-	for _, row := range rows {
-		utxo, err := mapRunesUTXOModelToType(row)
+	result := make([]*entity.OutPointBalance, 0, len(balances))
+	for _, balanceModel := range balances {
+		balance, err := mapOutPointBalanceModelToType(balanceModel)
 		if err != nil {
-			return nil, errors.Wrap(err, "failed to parse row model")
+			return nil, errors.Wrap(err, "failed to parse balance model")
 		}
-		result = append(result, &utxo)
-	}
-	return result, nil
-}
-
-func (r *Repository) GetRunesUTXOsByRuneIdAndPkScript(ctx context.Context, runeId runes.RuneId, pkScript []byte, blockHeight uint64, limit int32, offset int32) ([]*entity.RunesUTXO, error) {
-	if limit == -1 {
-		limit = math.MaxInt32
-	}
-	if limit < 0 {
-		return nil, errors.Wrap(errs.InvalidArgument, "limit must be -1 or non-negative")
-	}
-	rows, err := r.queries.GetRunesUTXOsByRuneIdAndPkScript(ctx, gen.GetRunesUTXOsByRuneIdAndPkScriptParams{
-		Pkscript:    hex.EncodeToString(pkScript),
-		BlockHeight: int32(blockHeight),
-		RuneIds:     []string{runeId.String()},
-		Limit:       limit,
-		Offset:      offset,
-	})
-	if err != nil {
-		return nil, errors.Wrap(err, "error during query")
-	}
-
-	result := make([]*entity.RunesUTXO, 0, len(rows))
-	for _, row := range rows {
-		utxo, err := mapRunesUTXOModelToType(gen.GetRunesUTXOsByPkScriptRow(row))
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to parse row")
-		}
-		result = append(result, &utxo)
+		result = append(result, &balance)
 	}
 	return result, nil
 }
@@ -324,46 +245,30 @@ func (r *Repository) CountRuneEntries(ctx context.Context) (uint64, error) {
 	return uint64(count), nil
 }
 
-func (r *Repository) GetBalancesByPkScript(ctx context.Context, pkScript []byte, blockHeight uint64, limit int32, offset int32) ([]*entity.Balance, error) {
-	if limit == -1 {
-		limit = math.MaxInt32
-	}
-	if limit < 0 {
-		return nil, errors.Wrap(errs.InvalidArgument, "limit must be -1 or non-negative")
-	}
+func (r *Repository) GetBalancesByPkScript(ctx context.Context, pkScript []byte, blockHeight uint64) (map[runes.RuneId]*entity.Balance, error) {
 	balances, err := r.queries.GetBalancesByPkScript(ctx, gen.GetBalancesByPkScriptParams{
 		Pkscript:    hex.EncodeToString(pkScript),
 		BlockHeight: int32(blockHeight),
-		Limit:       limit,
-		Offset:      offset,
 	})
 	if err != nil {
 		return nil, errors.Wrap(err, "error during query")
 	}
 
-	result := make([]*entity.Balance, 0, len(balances))
+	result := make(map[runes.RuneId]*entity.Balance, len(balances))
 	for _, balanceModel := range balances {
 		balance, err := mapBalanceModelToType(gen.RunesBalance(balanceModel))
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to parse balance model")
 		}
-		result = append(result, balance)
+		result[balance.RuneId] = balance
 	}
 	return result, nil
 }
 
-func (r *Repository) GetBalancesByRuneId(ctx context.Context, runeId runes.RuneId, blockHeight uint64, limit int32, offset int32) ([]*entity.Balance, error) {
-	if limit == -1 {
-		limit = math.MaxInt32
-	}
-	if limit < 0 {
-		return nil, errors.Wrap(errs.InvalidArgument, "limit must be -1 or non-negative")
-	}
+func (r *Repository) GetBalancesByRuneId(ctx context.Context, runeId runes.RuneId, blockHeight uint64) ([]*entity.Balance, error) {
 	balances, err := r.queries.GetBalancesByRuneId(ctx, gen.GetBalancesByRuneIdParams{
 		RuneID:      runeId.String(),
 		BlockHeight: int32(blockHeight),
-		Limit:       limit,
-		Offset:      offset,
 	})
 	if err != nil {
 		return nil, errors.Wrap(err, "error during query")

modules/runes/runes/rune.go

@@ -29,10 +29,6 @@ var ErrInvalidBase26 = errors.New("invalid base-26 character: must be in the ran
 func NewRuneFromString(value string) (Rune, error) {
 	n := uint128.From64(0)
 	for i, char := range value {
-		// skip spacers
-		if char == '.' || char == '•' {
-			continue
-		}
 		if i > 0 {
 			n = n.Add(uint128.From64(1))
 		}

modules/runes/usecase/errs.go

@@ -1,5 +0,0 @@
-package usecase
-
-import "github.com/cockroachdb/errors"
-
-var ErrUTXONotFound = errors.New("utxo not found")

modules/runes/usecase/get_balances.go

@@ -8,18 +8,16 @@ import (
 	"github.com/gaze-network/indexer-network/modules/runes/runes"
 )
 
-// Use limit = -1 as no limit.
-func (u *Usecase) GetBalancesByPkScript(ctx context.Context, pkScript []byte, blockHeight uint64, limit int32, offset int32) ([]*entity.Balance, error) {
-	balances, err := u.runesDg.GetBalancesByPkScript(ctx, pkScript, blockHeight, limit, offset)
+func (u *Usecase) GetBalancesByPkScript(ctx context.Context, pkScript []byte, blockHeight uint64) (map[runes.RuneId]*entity.Balance, error) {
+	balances, err := u.runesDg.GetBalancesByPkScript(ctx, pkScript, blockHeight)
 	if err != nil {
 		return nil, errors.Wrap(err, "error during GetBalancesByPkScript")
 	}
 	return balances, nil
 }
 
-// Use limit = -1 as no limit.
-func (u *Usecase) GetBalancesByRuneId(ctx context.Context, runeId runes.RuneId, blockHeight uint64, limit int32, offset int32) ([]*entity.Balance, error) {
-	balances, err := u.runesDg.GetBalancesByRuneId(ctx, runeId, blockHeight, limit, offset)
+func (u *Usecase) GetBalancesByRuneId(ctx context.Context, runeId runes.RuneId, blockHeight uint64) ([]*entity.Balance, error) {
+	balances, err := u.runesDg.GetBalancesByRuneId(ctx, runeId, blockHeight)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to get rune holders by rune id")
 	}

modules/runes/usecase/get_outpoint_balances.go

@@ -0,0 +1,16 @@
+package usecase
+
+import (
+	"context"
+
+	"github.com/cockroachdb/errors"
+	"github.com/gaze-network/indexer-network/modules/runes/internal/entity"
+)
+
+func (u *Usecase) GetUnspentOutPointBalancesByPkScript(ctx context.Context, pkScript []byte, blockHeight uint64) ([]*entity.OutPointBalance, error) {
+	balances, err := u.runesDg.GetUnspentOutPointBalancesByPkScript(ctx, pkScript, blockHeight)
+	if err != nil {
+		return nil, errors.Wrap(err, "error during GetBalancesByPkScript")
+	}
+	return balances, nil
+}

modules/runes/usecase/get_transactions.go

@@ -8,9 +8,8 @@ import (
 	"github.com/gaze-network/indexer-network/modules/runes/runes"
 )
 
-// Use limit = -1 as no limit.
-func (u *Usecase) GetRuneTransactions(ctx context.Context, pkScript []byte, runeId runes.RuneId, fromBlock, toBlock uint64, limit int32, offset int32) ([]*entity.RuneTransaction, error) {
-	txs, err := u.runesDg.GetRuneTransactions(ctx, pkScript, runeId, fromBlock, toBlock, limit, offset)
+func (u *Usecase) GetRuneTransactions(ctx context.Context, pkScript []byte, runeId runes.RuneId, fromBlock, toBlock uint64) ([]*entity.RuneTransaction, error) {
+	txs, err := u.runesDg.GetRuneTransactions(ctx, pkScript, runeId, fromBlock, toBlock)
 	if err != nil {
 		return nil, errors.Wrap(err, "error during GetTransactionsByHeight")
 	}

modules/runes/usecase/get_utxos.go

@@ -1,119 +0,0 @@
-package usecase
-
-import (
-	"context"
-	"strings"
-
-	"github.com/btcsuite/btcd/chaincfg/chainhash"
-	"github.com/btcsuite/btcd/wire"
-	"github.com/cockroachdb/errors"
-	"github.com/gaze-network/indexer-network/common/errs"
-	"github.com/gaze-network/indexer-network/modules/runes/internal/entity"
-	"github.com/gaze-network/indexer-network/modules/runes/runes"
-)
-
-func (u *Usecase) GetRunesUTXOsByPkScript(ctx context.Context, pkScript []byte, blockHeight uint64, limit int32, offset int32) ([]*entity.RunesUTXOWithSats, error) {
-	balances, err := u.runesDg.GetRunesUTXOsByPkScript(ctx, pkScript, blockHeight, limit, offset)
-	if err != nil {
-		return nil, errors.Wrap(err, "error during GetBalancesByPkScript")
-	}
-
-	result := make([]*entity.RunesUTXOWithSats, 0, len(balances))
-	for _, balance := range balances {
-		tx, err := u.bitcoinClient.GetRawTransactionByTxHash(ctx, balance.OutPoint.Hash)
-		if err != nil {
-			if strings.Contains(err.Error(), "No such mempool or blockchain transaction.") {
-				return nil, errors.WithStack(ErrUTXONotFound)
-			}
-			return nil, errors.WithStack(err)
-		}
-
-		result = append(result, &entity.RunesUTXOWithSats{
-			RunesUTXO: entity.RunesUTXO{
-				PkScript:     balance.PkScript,
-				OutPoint:     balance.OutPoint,
-				RuneBalances: balance.RuneBalances,
-			},
-			Sats: tx.TxOut[balance.OutPoint.Index].Value,
-		})
-	}
-
-	return result, nil
-}
-
-func (u *Usecase) GetRunesUTXOsByRuneIdAndPkScript(ctx context.Context, runeId runes.RuneId, pkScript []byte, blockHeight uint64, limit int32, offset int32) ([]*entity.RunesUTXOWithSats, error) {
-	balances, err := u.runesDg.GetRunesUTXOsByRuneIdAndPkScript(ctx, runeId, pkScript, blockHeight, limit, offset)
-	if err != nil {
-		return nil, errors.Wrap(err, "error during GetBalancesByPkScript")
-	}
-
-	result := make([]*entity.RunesUTXOWithSats, 0, len(balances))
-	for _, balance := range balances {
-		tx, err := u.bitcoinClient.GetRawTransactionByTxHash(ctx, balance.OutPoint.Hash)
-		if err != nil {
-			if strings.Contains(err.Error(), "No such mempool or blockchain transaction.") {
-				return nil, errors.WithStack(ErrUTXONotFound)
-			}
-			return nil, errors.WithStack(err)
-		}
-
-		result = append(result, &entity.RunesUTXOWithSats{
-			RunesUTXO: entity.RunesUTXO{
-				PkScript:     balance.PkScript,
-				OutPoint:     balance.OutPoint,
-				RuneBalances: balance.RuneBalances,
-			},
-			Sats: tx.TxOut[balance.OutPoint.Index].Value,
-		})
-	}
-
-	return result, nil
-}
-
-func (u *Usecase) GetUTXOsOutputByLocation(ctx context.Context, txHash chainhash.Hash, outputIdx uint32) (*entity.RunesUTXOWithSats, error) {
-	tx, err := u.bitcoinClient.GetRawTransactionByTxHash(ctx, txHash)
-	if err != nil {
-		if strings.Contains(err.Error(), "No such mempool or blockchain transaction.") {
-			return nil, errors.WithStack(ErrUTXONotFound)
-		}
-		return nil, errors.WithStack(err)
-	}
-
-	// If the output index is out of range, return an error
-	if len(tx.TxOut) <= int(outputIdx) {
-		return nil, errors.WithStack(ErrUTXONotFound)
-	}
-
-	rune := &entity.RunesUTXOWithSats{
-		RunesUTXO: entity.RunesUTXO{
-			PkScript: tx.TxOut[0].PkScript,
-			OutPoint: wire.OutPoint{
-				Hash:  txHash,
-				Index: outputIdx,
-			},
-		},
-		Sats: tx.TxOut[outputIdx].Value,
-	}
-
-	transaction, err := u.runesDg.GetRuneTransaction(ctx, txHash)
-	// If Bitcoin transaction is not found in the database, return the PkScript and OutPoint
-	if errors.Is(err, errs.NotFound) {
-		return rune, nil
-	}
-	if err != nil {
-		return nil, errors.WithStack(err)
-	}
-
-	runeBalance := make([]entity.RunesUTXOBalance, 0, len(transaction.Outputs))
-	for _, output := range transaction.Outputs {
-		if output.Index == outputIdx {
-			runeBalance = append(runeBalance, entity.RunesUTXOBalance{
-				RuneId: output.RuneId,
-				Amount: output.Amount,
-			})
-		}
-	}
-
-	rune.RuneBalances = runeBalance
-	return rune, nil
-}

pkg/btcclient/contract.go

@@ -9,6 +9,4 @@ import (
 
 type Contract interface {
 	GetRawTransactionAndHeightByTxHash(ctx context.Context, txHash chainhash.Hash) (*wire.MsgTx, int64, error)
-
-	GetRawTransactionByTxHash(ctx context.Context, txHash chainhash.Hash) (*wire.MsgTx, error)
 }

pkg/httpclient/httpclient.go

@@ -64,14 +64,13 @@ func (r *HttpResponse) UnmarshalBody(out any) error {
 	if err != nil {
 		return errors.Wrapf(err, "can't uncompress body from %v", r.URL)
 	}
-	contentType := strings.ToLower(string(r.Header.ContentType()))
-	switch {
-	case strings.Contains(contentType, "application/json"):
+	switch strings.ToLower(string(r.Header.ContentType())) {
+	case "application/json", "application/json; charset=utf-8":
 		if err := json.Unmarshal(body, out); err != nil {
 			return errors.Wrapf(err, "can't unmarshal json body from %s, %q", r.URL, string(body))
 		}
 		return nil
-	case strings.Contains(contentType, "text/plain"):
+	case "text/plain", "text/plain; charset=utf-8":
 		return errors.Errorf("can't unmarshal plain text %q", string(body))
 	default:
 		return errors.Errorf("unsupported content type: %s, contents: %v", r.Header.ContentType(), string(r.Body()))
@@ -91,10 +90,6 @@ func (h *Client) request(ctx context.Context, reqOptions RequestOptions) (*HttpR
 
 	parsedUrl := h.BaseURL()
 	parsedUrl.Path = path.Join(parsedUrl.Path, reqOptions.path)
-	// Because path.Join cleans the joined path. If path ends with /, append "/" to parsedUrl.Path
-	if strings.HasSuffix(reqOptions.path, "/") && !strings.HasSuffix(parsedUrl.Path, "/") {
-		parsedUrl.Path += "/"
-	}
 	baseQuery := parsedUrl.Query()
 	for k, v := range reqOptions.Query {
 		baseQuery[k] = v