Improved Filtering options

components/app/app.go

@@ -14,7 +14,7 @@ var (
 	Name = "inx-indexer"
 
 	// Version of the app.
-	Version = "1.0.0-rc.3"
+	Version = "1.0.0-rc.4"
 )
 
 func App() *app.App {

pkg/indexer/alias.go

@@ -5,6 +5,8 @@ import (
 	"fmt"
 	"time"
 
+	"gorm.io/gorm"
+
 	iotago "github.com/iotaledger/iota.go/v3"
 )
 
@@ -27,6 +29,7 @@ type AliasFilterOptions struct {
 	hasNativeTokens     *bool
 	minNativeTokenCount *uint32
 	maxNativeTokenCount *uint32
+	unlockableByAddress *iotago.Address
 	stateController     *iotago.Address
 	governor            *iotago.Address
 	issuer              *iotago.Address
@@ -57,6 +60,12 @@ func AliasMaxNativeTokenCount(value uint32) AliasFilterOption {
 	}
 }
 
+func AliasUnlockableByAddress(address iotago.Address) AliasFilterOption {
+	return func(args *AliasFilterOptions) {
+		args.unlockableByAddress = &address
+	}
+}
+
 func AliasStateController(address iotago.Address) AliasFilterOption {
 	return func(args *AliasFilterOptions) {
 		args.stateController = &address
@@ -123,8 +132,7 @@ func (i *Indexer) AliasOutput(aliasID *iotago.AliasID) *IndexerResult {
 	return i.combineOutputIDFilteredQuery(query, 0, nil)
 }
 
-func (i *Indexer) AliasOutputsWithFilters(filter ...AliasFilterOption) *IndexerResult {
-	opts := aliasFilterOptions(filter)
+func (i *Indexer) aliasQueryWithFilter(opts *AliasFilterOptions) (*gorm.DB, error) {
 	query := i.db.Model(&alias{})
 
 	if opts.hasNativeTokens != nil {
@@ -143,34 +151,42 @@ func (i *Indexer) AliasOutputsWithFilters(filter ...AliasFilterOption) *IndexerR
 		query = query.Where("native_token_count <= ?", *opts.maxNativeTokenCount)
 	}
 
+	if opts.unlockableByAddress != nil {
+		addr, err := addressBytesForAddress(*opts.unlockableByAddress)
+		if err != nil {
+			return nil, err
+		}
+		query = query.Where("(state_controller = ? OR governor = ?)", addr[:], addr[:])
+	}
+
 	if opts.stateController != nil {
 		addr, err := addressBytesForAddress(*opts.stateController)
 		if err != nil {
-			return errorResult(err)
+			return nil, err
 		}
 		query = query.Where("state_controller = ?", addr[:])
 	}
 
 	if opts.governor != nil {
 		addr, err := addressBytesForAddress(*opts.governor)
 		if err != nil {
-			return errorResult(err)
+			return nil, err
 		}
 		query = query.Where("governor = ?", addr[:])
 	}
 
 	if opts.sender != nil {
 		addr, err := addressBytesForAddress(*opts.sender)
 		if err != nil {
-			return errorResult(err)
+			return nil, err
 		}
 		query = query.Where("sender = ?", addr[:])
 	}
 
 	if opts.issuer != nil {
 		addr, err := addressBytesForAddress(*opts.issuer)
 		if err != nil {
-			return errorResult(err)
+			return nil, err
 		}
 		query = query.Where("issuer = ?", addr[:])
 	}
@@ -183,5 +199,15 @@ func (i *Indexer) AliasOutputsWithFilters(filter ...AliasFilterOption) *IndexerR
 		query = query.Where("created_at > ?", *opts.createdAfter)
 	}
 
+	return query, nil
+}
+
+func (i *Indexer) AliasOutputsWithFilters(filter ...AliasFilterOption) *IndexerResult {
+	opts := aliasFilterOptions(filter)
+	query, err := i.aliasQueryWithFilter(opts)
+	if err != nil {
+		return errorResult(err)
+	}
+
 	return i.combineOutputIDFilteredQuery(query, opts.pageSize, opts.cursor)
 }

pkg/indexer/basic_output.go

@@ -5,6 +5,8 @@ import (
 	"fmt"
 	"time"
 
+	"gorm.io/gorm"
+
 	iotago "github.com/iotaledger/iota.go/v3"
 )
 
@@ -31,6 +33,7 @@ type BasicOutputFilterOptions struct {
 	minNativeTokenCount              *uint32
 	maxNativeTokenCount              *uint32
 	unlockableByAddress              *iotago.Address
+	address                          *iotago.Address
 	hasStorageDepositReturnCondition *bool
 	storageDepositReturnAddress      *iotago.Address
 	hasExpirationCondition           *bool
@@ -74,6 +77,12 @@ func BasicOutputUnlockableByAddress(address iotago.Address) BasicOutputFilterOpt
 	}
 }
 
+func BasicOutputUnlockAddress(address iotago.Address) BasicOutputFilterOption {
+	return func(args *BasicOutputFilterOptions) {
+		args.address = &address
+	}
+}
+
 func BasicOutputHasStorageDepositReturnCondition(value bool) BasicOutputFilterOption {
 	return func(args *BasicOutputFilterOptions) {
 		args.hasStorageDepositReturnCondition = &value
@@ -174,8 +183,7 @@ func basicOutputFilterOptions(optionalOptions []BasicOutputFilterOption) *BasicO
 	return result
 }
 
-func (i *Indexer) BasicOutputsWithFilters(filters ...BasicOutputFilterOption) *IndexerResult {
-	opts := basicOutputFilterOptions(filters)
+func (i *Indexer) basicOutputsQueryWithFilter(opts *BasicOutputFilterOptions) (*gorm.DB, error) {
 	query := i.db.Model(&basicOutput{})
 
 	if opts.hasNativeTokens != nil {
@@ -197,7 +205,15 @@ func (i *Indexer) BasicOutputsWithFilters(filters ...BasicOutputFilterOption) *I
 	if opts.unlockableByAddress != nil {
 		addr, err := addressBytesForAddress(*opts.unlockableByAddress)
 		if err != nil {
-			return errorResult(err)
+			return nil, err
+		}
+		query = query.Where("(address = ? OR expiration_return_address = ? OR storage_deposit_return_address = ?)", addr[:], addr[:], addr[:])
+	}
+
+	if opts.address != nil {
+		addr, err := addressBytesForAddress(*opts.address)
+		if err != nil {
+			return nil, err
 		}
 		query = query.Where("address = ?", addr[:])
 	}
@@ -213,7 +229,7 @@ func (i *Indexer) BasicOutputsWithFilters(filters ...BasicOutputFilterOption) *I
 	if opts.storageDepositReturnAddress != nil {
 		addr, err := addressBytesForAddress(*opts.storageDepositReturnAddress)
 		if err != nil {
-			return errorResult(err)
+			return nil, err
 		}
 		query = query.Where("storage_deposit_return_address = ?", addr[:])
 	}
@@ -229,7 +245,7 @@ func (i *Indexer) BasicOutputsWithFilters(filters ...BasicOutputFilterOption) *I
 	if opts.expirationReturnAddress != nil {
 		addr, err := addressBytesForAddress(*opts.expirationReturnAddress)
 		if err != nil {
-			return errorResult(err)
+			return nil, err
 		}
 		query = query.Where("expiration_return_address = ?", addr[:])
 	}
@@ -261,7 +277,7 @@ func (i *Indexer) BasicOutputsWithFilters(filters ...BasicOutputFilterOption) *I
 	if opts.sender != nil {
 		addr, err := addressBytesForAddress(*opts.sender)
 		if err != nil {
-			return errorResult(err)
+			return nil, err
 		}
 		query = query.Where("sender = ?", addr[:])
 	}
@@ -278,5 +294,15 @@ func (i *Indexer) BasicOutputsWithFilters(filters ...BasicOutputFilterOption) *I
 		query = query.Where("created_at > ?", *opts.createdAfter)
 	}
 
+	return query, nil
+}
+
+func (i *Indexer) BasicOutputsWithFilters(filters ...BasicOutputFilterOption) *IndexerResult {
+	opts := basicOutputFilterOptions(filters)
+	query, err := i.basicOutputsQueryWithFilter(opts)
+	if err != nil {
+		return errorResult(err)
+	}
+
 	return i.combineOutputIDFilteredQuery(query, opts.pageSize, opts.cursor)
 }

pkg/indexer/combined.go

@@ -0,0 +1,142 @@
+package indexer
+
+import (
+	"time"
+
+	"gorm.io/gorm"
+
+	iotago "github.com/iotaledger/iota.go/v3"
+)
+
+type CombinedFilterOptions struct {
+	hasNativeTokens     *bool
+	minNativeTokenCount *uint32
+	maxNativeTokenCount *uint32
+	unlockableByAddress *iotago.Address
+	pageSize            uint32
+	cursor              *string
+	createdBefore       *time.Time
+	createdAfter        *time.Time
+}
+
+type CombinedFilterOption func(*CombinedFilterOptions)
+
+func CombinedHasNativeTokens(value bool) CombinedFilterOption {
+	return func(args *CombinedFilterOptions) {
+		args.hasNativeTokens = &value
+	}
+}
+
+func CombinedMinNativeTokenCount(value uint32) CombinedFilterOption {
+	return func(args *CombinedFilterOptions) {
+		args.minNativeTokenCount = &value
+	}
+}
+
+func CombinedMaxNativeTokenCount(value uint32) CombinedFilterOption {
+	return func(args *CombinedFilterOptions) {
+		args.maxNativeTokenCount = &value
+	}
+}
+
+func CombinedUnlockableByAddress(address iotago.Address) CombinedFilterOption {
+	return func(args *CombinedFilterOptions) {
+		args.unlockableByAddress = &address
+	}
+}
+
+func CombinedPageSize(pageSize uint32) CombinedFilterOption {
+	return func(args *CombinedFilterOptions) {
+		args.pageSize = pageSize
+	}
+}
+
+func CombinedCursor(cursor string) CombinedFilterOption {
+	return func(args *CombinedFilterOptions) {
+		args.cursor = &cursor
+	}
+}
+
+func CombinedCreatedBefore(time time.Time) CombinedFilterOption {
+	return func(args *CombinedFilterOptions) {
+		args.createdBefore = &time
+	}
+}
+
+func CombinedCreatedAfter(time time.Time) CombinedFilterOption {
+	return func(args *CombinedFilterOptions) {
+		args.createdAfter = &time
+	}
+}
+
+func combinedFilterOptions(optionalOptions []CombinedFilterOption) *CombinedFilterOptions {
+	result := &CombinedFilterOptions{}
+
+	for _, optionalOption := range optionalOptions {
+		optionalOption(result)
+	}
+
+	return result
+}
+
+func (o *CombinedFilterOptions) BasicFilterOptions() *BasicOutputFilterOptions {
+	return &BasicOutputFilterOptions{
+		hasNativeTokens:     o.hasNativeTokens,
+		minNativeTokenCount: o.minNativeTokenCount,
+		maxNativeTokenCount: o.maxNativeTokenCount,
+		unlockableByAddress: o.unlockableByAddress,
+		pageSize:            o.pageSize,
+		cursor:              o.cursor,
+		createdBefore:       o.createdBefore,
+		createdAfter:        o.createdAfter,
+	}
+}
+
+func (o *CombinedFilterOptions) AliasFilterOptions() *AliasFilterOptions {
+	return &AliasFilterOptions{
+		hasNativeTokens:     o.hasNativeTokens,
+		minNativeTokenCount: o.minNativeTokenCount,
+		maxNativeTokenCount: o.maxNativeTokenCount,
+		unlockableByAddress: o.unlockableByAddress,
+		pageSize:            o.pageSize,
+		cursor:              o.cursor,
+		createdBefore:       o.createdBefore,
+		createdAfter:        o.createdAfter,
+	}
+}
+
+func (o *CombinedFilterOptions) NFTFilterOptions() *NFTFilterOptions {
+	return &NFTFilterOptions{
+		hasNativeTokens:     o.hasNativeTokens,
+		minNativeTokenCount: o.minNativeTokenCount,
+		maxNativeTokenCount: o.maxNativeTokenCount,
+		unlockableByAddress: o.unlockableByAddress,
+		pageSize:            o.pageSize,
+		cursor:              o.cursor,
+		createdBefore:       o.createdBefore,
+		createdAfter:        o.createdAfter,
+	}
+}
+
+func (i *Indexer) CombinedOutputsWithFilters(filters ...CombinedFilterOption) *IndexerResult {
+	opts := combinedFilterOptions(filters)
+
+	basicQuery, err := i.basicOutputsQueryWithFilter(opts.BasicFilterOptions())
+	if err != nil {
+		return errorResult(err)
+	}
+
+	aliasQuery, err := i.aliasQueryWithFilter(opts.AliasFilterOptions())
+	if err != nil {
+		return errorResult(err)
+	}
+
+	nftQuery, err := i.nftOutputsQueryWithFilter(opts.NFTFilterOptions())
+	if err != nil {
+		return errorResult(err)
+	}
+
+	queries := []*gorm.DB{basicQuery, aliasQuery, nftQuery}
+
+	return i.combineOutputIDFilteredQueries(queries, opts.pageSize, opts.cursor)
+}

pkg/indexer/foundry.go

@@ -5,6 +5,8 @@ import (
 	"fmt"
 	"time"
 
+	"gorm.io/gorm"
+
 	iotago "github.com/iotaledger/iota.go/v3"
 )
 
@@ -99,8 +101,7 @@ func (i *Indexer) FoundryOutput(foundryID *iotago.FoundryID) *IndexerResult {
 	return i.combineOutputIDFilteredQuery(query, 0, nil)
 }
 
-func (i *Indexer) FoundryOutputsWithFilters(filters ...FoundryFilterOption) *IndexerResult {
-	opts := foundryFilterOptions(filters)
+func (i *Indexer) foundryOutputsQueryWithFilter(opts *FoundryFilterOptions) (*gorm.DB, error) {
 	query := i.db.Model(&foundry{})
 
 	if opts.hasNativeTokens != nil {
@@ -122,7 +123,7 @@ func (i *Indexer) FoundryOutputsWithFilters(filters ...FoundryFilterOption) *Ind
 	if opts.aliasAddress != nil {
 		addr, err := addressBytesForAddress(opts.aliasAddress)
 		if err != nil {
-			return errorResult(err)
+			return nil, err
 		}
 		query = query.Where("alias_address = ?", addr[:])
 	}
@@ -135,5 +136,15 @@ func (i *Indexer) FoundryOutputsWithFilters(filters ...FoundryFilterOption) *Ind
 		query = query.Where("created_at > ?", *opts.createdAfter)
 	}
 
+	return query, nil
+}
+
+func (i *Indexer) FoundryOutputsWithFilters(filters ...FoundryFilterOption) *IndexerResult {
+	opts := foundryFilterOptions(filters)
+	query, err := i.foundryOutputsQueryWithFilter(opts)
+	if err != nil {
+		return errorResult(err)
+	}
+
 	return i.combineOutputIDFilteredQuery(query, opts.pageSize, opts.cursor)
 }