asset+scripts+tapd: allow querying multiple script key types

This introduces a workaround that gets us WHERE xxx IN (...) queries
working with a little trick. See the comment in
scripts/gen_sqlc_docker.sh for more information on how this works and
why the workaround is needed.

Author: guggero

asset/asset.go

@@ -152,6 +152,61 @@ const (
 	ScriptKeyScriptPathChannel ScriptKeyType = 5
 )
 
+var (
+	// AllScriptKeyTypes is a slice of all known script key types.
+	AllScriptKeyTypes = []ScriptKeyType{
+		ScriptKeyUnknown,
+		ScriptKeyBip86,
+		ScriptKeyScriptPathExternal,
+		ScriptKeyBurn,
+		ScriptKeyTombstone,
+		ScriptKeyScriptPathChannel,
+	}
+
+	// ScriptKeyTypesNoChannel is a slice of all known script key types
+	// that are not related to channels. This is used to filter out channel
+	// related script keys when querying for assets that are not related to
+	// channels.
+	ScriptKeyTypesNoChannel = []ScriptKeyType{
+		ScriptKeyUnknown,
+		ScriptKeyBip86,
+		ScriptKeyScriptPathExternal,
+		ScriptKeyBurn,
+		ScriptKeyTombstone,
+	}
+)
+
+// ScriptKeyTypeForDatabaseQuery returns a slice of script key types that should
+// be used when querying the database for assets. The returned slice will either
+// contain all script key types or only those that are not related to channels,
+// depending on the `filterChannelRelated` parameter. Unless the user specifies
+// a specific script key type, in which case the returned slice will only
+// contain that specific script key type.
+func ScriptKeyTypeForDatabaseQuery(filterChannelRelated bool,
+	userSpecified fn.Option[ScriptKeyType]) []ScriptKeyType {
+
+	// For some queries, we want to get all the assets with all possible
+	// script key types. For those, we use the full set of script key types.
+	dbTypes := fn.CopySlice(AllScriptKeyTypes)
+
+	// For some RPCs (mostly balance related), we exclude the assets that
+	// are specifically used for funding custom channels by default. The
+	// balance of those assets is reported through lnd channel balance.
+	// Those assets are identified by the specific script key type for
+	// channel keys. We exclude them unless explicitly queried for.
+	if filterChannelRelated {
+		dbTypes = fn.CopySlice(ScriptKeyTypesNoChannel)
+	}
+
+	// If the user specified a script key type, we use that to filter the
+	// results.
+	userSpecified.WhenSome(func(t ScriptKeyType) {
+		dbTypes = []ScriptKeyType{t}
+	})
+
+	return dbTypes
+}
+
 var (
 	// ZeroPrevID is the blank prev ID used for genesis assets and also
 	// asset split leaves.

scripts/gen_sqlc_docker.sh

@@ -16,7 +16,8 @@ trap restore_files EXIT
 
 # Directory of the script file, independent of where it's called from.
 DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-# Use the user's cache directories
+
+# Use the user's cache directories.
 GOCACHE=$(go env GOCACHE)
 GOMODCACHE=$(go env GOMODCACHE)
 
@@ -46,3 +47,25 @@ docker run \
 	-v "$DIR/../:/build" \
 	-w /build \
 	sqlc/sqlc:1.29.0 generate
+
+# Because we're using the Postgres dialect of sqlc, we can't use sqlc.slice()
+# normally, because sqlc just thinks it can pass the Golang slice directly to
+# the database driver. So it doesn't put the /*SLICE:<field_name>*/ workaround
+# comment into the actual SQL query. But we add the comment ourselves and now
+# just need to replace the '$X/*SLICE:<field_name>*/' placeholders with the
+# actual placeholder that's going to be replaced by the sqlc generated code.
+echo "Applying sqlc.slice() workaround..."
+for file in tapdb/sqlc/*.sql.go; do
+  echo "Patching $file"
+
+  # First, we replace the `$X/*SLICE:<field_name>*/` placeholders with
+  # the actual placeholder that sqlc will use: `/*SLICE:<field_name>*/?`.
+  sed -i.bak -E 's/\$([0-9]+)\/\*SLICE:([a-zA-Z_][a-zA-Z0-9_]*)\*\//\/\*SLICE:\2\*\/\?/g' "$file"
+
+  # Then, we replace the `strings.Repeat(",?", len(arg.<golang_name>))[1:]` with
+  # a function call that generates the correct number of placeholders:
+  # `makeQueryParams(len(queryParams), len(arg.<golang_name>))`.
+  sed -i.bak -E 's/strings\.Repeat\(",\?", len\(([^)]+)\)\)\[1:\]/makeQueryParams(len(queryParams), len(\1))/g' "$file"
+  
+  rm "$file.bak"
+done

tapdb/assets_store.go

@@ -895,16 +895,34 @@ func (a *AssetStore) constraintsToDbFilter(
 			assetFilter.AssetIDFilter = nil
 		}
 
-		// The fn.None option means we don't restrict on script key type
-		// at all.
-		query.ScriptKeyType.WhenSome(func(t asset.ScriptKeyType) {
-			assetFilter.ScriptKeyType = sqlInt16(t)
-		})
+		// Let's figure out the set of script key types we want to
+		// query for. If the user specified a script key type, then we
+		// use that to filter the results. If the user didn't specify a
+		// script key type, then we use the full set of script key
+		// types, as this might be an internal query that also needs to
+		// know channel related assets.
+		assetFilter.ScriptKeyType = scriptKeyTypesForQuery(
+			false, query.ScriptKeyType,
+		)
 	}
 
 	return assetFilter, nil
 }
 
+// scriptKeyTypesForQuery returns the set of script key types we use in the
+// SQL queries based on the passed parameters. If the user specified a script
+// key type, then we use that to filter the results. If the user didn't
+// specify a script key type, then we use the full set of script key types
+// or the set of script key types that excludes channel related assets,
+// depending on the filterChannelRelated parameter.
+func scriptKeyTypesForQuery(filterChannelRelated bool,
+	userSpecified fn.Option[asset.ScriptKeyType]) []sql.NullInt16 {
+
+	return fn.Map(asset.ScriptKeyTypeForDatabaseQuery(
+		filterChannelRelated, userSpecified,
+	), sqlInt16)
+}
+
 // specificAssetFilter maps the given asset parameters to the set of filters
 // we use in the SQL queries.
 func (a *AssetStore) specificAssetFilter(id asset.ID, anchorPoint wire.OutPoint,
@@ -945,6 +963,17 @@ func fetchAssetsWithWitness(ctx context.Context, q ActiveAssetsStore,
 	assetFilter QueryAssetFilters) ([]ConfirmedAsset, assetWitnesses,
 	error) {
 
+	// We're using a slice of types to query for the set of script key
+	// types, which is turned into a `xxx IN (...)` SQL query. But that
+	// doesn't work for empty slices, as that would result in
+	// `xxx IN (NULL)` which evaluates to false. So we need to use all
+	// available types instead.
+	if len(assetFilter.ScriptKeyType) == 0 {
+		assetFilter.ScriptKeyType = fn.Map(
+			asset.AllScriptKeyTypes, sqlInt16,
+		)
+	}
+
 	// First, we'll fetch all the assets we know of on disk.
 	dbAssets, err := q.QueryAssets(ctx, assetFilter)
 	if err != nil {
@@ -1002,21 +1031,7 @@ func (a *AssetStore) QueryBalancesByAsset(ctx context.Context,
 	// channels. The balance of those assets is reported through lnd channel
 	// balance. Those assets are identified by the specific script key type
 	// for channel keys. We exclude them unless explicitly queried for.
-	assetBalancesFilter.ExcludeScriptKeyType = sqlInt16(
-		asset.ScriptKeyScriptPathChannel,
-	)
-
-	// The fn.None option means we don't restrict on script key type at all.
-	skt.WhenSome(func(t asset.ScriptKeyType) {
-		assetBalancesFilter.ScriptKeyType = sqlInt16(t)
-
-		// If the user explicitly wants to see the channel related asset
-		// balances, we need to set the exclude type to NULL.
-		if t == asset.ScriptKeyScriptPathChannel {
-			nullValue := sql.NullInt16{}
-			assetBalancesFilter.ExcludeScriptKeyType = nullValue
-		}
-	})
+	assetBalancesFilter.ScriptKeyType = scriptKeyTypesForQuery(true, skt)
 
 	// By default, we only show assets that are not leased.
 	if !includeLeased {
@@ -1094,21 +1109,7 @@ func (a *AssetStore) QueryAssetBalancesByGroup(ctx context.Context,
 	// channels. The balance of those assets is reported through lnd channel
 	// balance. Those assets are identified by the specific script key type
 	// for channel keys. We exclude them unless explicitly queried for.
-	assetBalancesFilter.ExcludeScriptKeyType = sqlInt16(
-		asset.ScriptKeyScriptPathChannel,
-	)
-
-	// The fn.None option means we don't restrict on script key type at all.
-	skt.WhenSome(func(t asset.ScriptKeyType) {
-		assetBalancesFilter.ScriptKeyType = sqlInt16(t)
-
-		// If the user explicitly wants to see the channel related asset
-		// balances, we need to set the exclude type to NULL.
-		if t == asset.ScriptKeyScriptPathChannel {
-			nullValue := sql.NullInt16{}
-			assetBalancesFilter.ExcludeScriptKeyType = nullValue
-		}
-	})
+	assetBalancesFilter.ScriptKeyType = scriptKeyTypesForQuery(true, skt)
 
 	// By default, we only show assets that are not leased.
 	if !includeLeased {