tapgarden+tapdb: misc review fixes, plus lint

Address golangci-lint findings (lll, gofmt, whitespace, exhaustive,
gosec, govet copylocks) and two reviewer comments: use uint for
mintpublish's batchSize so the negative-value case is ruled out at
the type boundary, and use the already-computed batchKey in the
Cultivator.Cancel default arm instead of re-deriving it from the
live batch.

The copylocks fixes switch the augmenter staging-batch construction
from `*batch` to `batch.Copy()` so the atomic state field isn't
copied by value. The exhaustive cases get explicit default arms on
the BatchState switches in checkSingletonInvariant and RunRepairTool.
Rename Migration62BackfillSupplyUpdateEventKeys to
Migration62BackfillEventKeys so the aligned map entry fits the
80-column limit.

Make TestMigration62BackfillSupplyUpdateEventKeys and
TestMigration62BackfillDedupesLegacyDuplicates portable to Postgres:
the first one used the SQLite-only `?` placeholder, the second used
MAX(bytea) which isn't defined in Postgres. Switch to sqlc's
InsertSupplyUpdateEvent and split COUNT + key lookup into two
queries. Regenerate sqlc bindings whose source-comment references
the event_key column's migration number.

Add a [repair] section to sample-tapd.conf with an example for
repair.cancel-duplicate-batches; the sample-conf check requires every
tapd flag to have a default or example in the file.

Author: jtobin

sample-tapd.conf

@@ -524,6 +524,16 @@
 ; required precision
 ; experimental.rfq.mockoraclesatsperasset=
 
+[repair]
+
+; One-shot recovery: when set, tapd cancels all but the most recent
+; minting batch in BatchStatePending or BatchStateFrozen and then
+; exits. Used to recover a legacy database that violates the
+; singleton pre-broadcast batch invariant added in migration 000060
+; (e.g. one with duplicate pending batches that blocks the
+; migration). Default value is false.
+; repair.cancel-duplicate-batches=false
+
 [healthcheck]
 
 ; The number of times we should attempt to check for certificate expiration before

tapcfg/repair.go

@@ -44,7 +44,7 @@ func RunRepairTool(cfg *Config, cfgLogger btclog.Logger) error {
 	case DatabaseBackendPostgres:
 		pgCfg := *cfg.Postgres
 		pgCfg.SkipMigrations = true
-		cfgLogger.Infof("repair: opening postgres database "+
+		cfgLogger.Infof("repair: opening postgres database " +
 			"(migrations skipped)")
 		db, err = tapdb.NewPostgresStore(&pgCfg)
 
@@ -77,6 +77,10 @@ func RunRepairTool(cfg *Config, cfgLogger btclog.Logger) error {
 			tapgarden.BatchStateFrozen:
 
 			preBroadcast = append(preBroadcast, batch)
+
+		default:
+			// Post-broadcast or terminal states are outside the
+			// singleton constraint and have nothing to repair.
 		}
 	}
 

tapdb/asset_minting_test.go

@@ -512,7 +512,9 @@ func TestCommitMintingBatchSeedlings(t *testing.T) {
 		t, assetStore, ctx, mintingBatch.Seedlings,
 	)
 	_, randSiblingHash := addRandSiblingToBatch(t, mintingBatch)
-	err := assetStore.CommitMintingBatch(ctx, mintingBatch, tapgarden.MockBindDataForBatch(mintingBatch))
+	err := assetStore.CommitMintingBatch(
+		ctx, mintingBatch, tapgarden.MockBindDataForBatch(mintingBatch),
+	)
 	require.NoError(t, err)
 
 	batchKey := mintingBatch.BatchKey.PubKey
@@ -616,7 +618,9 @@ func TestCommitMintingBatchSeedlings(t *testing.T) {
 	mintingBatch = tapgarden.RandMintingBatch(
 		t, tapgarden.WithTotalSeedlings(numSeedlings),
 	)
-	err = assetStore.CommitMintingBatch(ctx, mintingBatch, tapgarden.MockBindDataForBatch(mintingBatch))
+	err = assetStore.CommitMintingBatch(
+		ctx, mintingBatch, tapgarden.MockBindDataForBatch(mintingBatch),
+	)
 	require.NoError(t, err)
 	mintingBatches = noError1(t, assetStore.FetchNonFinalBatches, ctx)
 	assertSeedlingBatchLen(t, mintingBatches, 1, numSeedlings)
@@ -657,7 +661,9 @@ func TestInsertFetchUniCommitBatch(t *testing.T) {
 	require.True(t, seedling.DelegationKey.IsSome())
 
 	// Commit the minting batch to the database.
-	err := assetStore.CommitMintingBatch(ctx, batch, tapgarden.MockBindDataForBatch(batch))
+	err := assetStore.CommitMintingBatch(
+		ctx, batch, tapgarden.MockBindDataForBatch(batch),
+	)
 	require.NoError(t, err)
 
 	// Fetch the same batch from the database.
@@ -878,7 +884,9 @@ func TestAddSproutsToBatch(t *testing.T) {
 	}
 
 	// First, we'll create a new batch, then add some sample seedlings.
-	require.NoError(t, assetStore.CommitMintingBatch(ctx, mintingBatch, tapgarden.MockBindDataForBatch(mintingBatch)))
+	require.NoError(t, assetStore.CommitMintingBatch(
+		ctx, mintingBatch, tapgarden.MockBindDataForBatch(mintingBatch),
+	))
 
 	// Now that the batch is on disk, we'll map those seedlings to an
 	// actual asset commitment, then insert them into the DB as sprouts.
@@ -970,7 +978,9 @@ func addRandAssets(t *testing.T, ctx context.Context,
 		t, assetStore, ctx, mintingBatch.Seedlings,
 	)
 	randSibling, randSiblingHash := addRandSiblingToBatch(t, mintingBatch)
-	require.NoError(t, assetStore.CommitMintingBatch(ctx, mintingBatch, tapgarden.MockBindDataForBatch(mintingBatch)))
+	require.NoError(t, assetStore.CommitMintingBatch(
+		ctx, mintingBatch, tapgarden.MockBindDataForBatch(mintingBatch),
+	))
 
 	genesisPacket := mintingBatch.GenesisPacket
 	assetRoot := seedlingsToAssetRoot(
@@ -1496,7 +1506,9 @@ func TestGroupAnchors(t *testing.T) {
 		t, assetStore, ctx, mintingBatch.Seedlings,
 	)
 	addMultiAssetGroupToBatch(mintingBatch.Seedlings)
-	err := assetStore.CommitMintingBatch(ctx, mintingBatch, tapgarden.MockBindDataForBatch(mintingBatch))
+	err := assetStore.CommitMintingBatch(
+		ctx, mintingBatch, tapgarden.MockBindDataForBatch(mintingBatch),
+	)
 	require.NoError(t, err)
 
 	batchKey := mintingBatch.BatchKey.PubKey
@@ -2018,7 +2030,9 @@ func TestUpsertMintSupplyPreCommit(t *testing.T) {
 	storeSeedlingGroupGenesis(t, ctx, assetStore, seedling)
 
 	// Commit batch.
-	require.NoError(t, assetStore.CommitMintingBatch(ctx, mintingBatch, tapgarden.MockBindDataForBatch(mintingBatch)))
+	require.NoError(t, assetStore.CommitMintingBatch(
+		ctx, mintingBatch, tapgarden.MockBindDataForBatch(mintingBatch),
+	))
 
 	// Retrieve the batch key of the batch we just inserted.
 	var batchKey []byte
@@ -2073,13 +2087,13 @@ func TestUpsertMintSupplyPreCommit(t *testing.T) {
 	internalKey2, _ := test.RandKeyDesc(t)
 
 	storeMintSupplyPreCommit(
-		t, *assetStore, batchKey, preCommitBind.OutputIndex, internalKey2,
-		groupPubKeyBytes, preCommitOutpoint,
+		t, *assetStore, batchKey, preCommitBind.OutputIndex,
+		internalKey2, groupPubKeyBytes, preCommitOutpoint,
 	)
 
 	assertMintSupplyPreCommit(
-		t, *assetStore, batchKey, preCommitBind.OutputIndex, internalKey2,
-		groupPubKeyBytes, preCommitOutpoint,
+		t, *assetStore, batchKey, preCommitBind.OutputIndex,
+		internalKey2, groupPubKeyBytes, preCommitOutpoint,
 	)
 
 	// Upsert-ing a new group key for the same pre-commit outpoint should
@@ -2088,13 +2102,13 @@ func TestUpsertMintSupplyPreCommit(t *testing.T) {
 	groupPubKey2Bytes := schnorr.SerializePubKey(groupPubKey2)
 
 	storeMintSupplyPreCommit(
-		t, *assetStore, batchKey, preCommitBind.OutputIndex, internalKey2,
-		groupPubKey2Bytes, preCommitOutpoint,
+		t, *assetStore, batchKey, preCommitBind.OutputIndex,
+		internalKey2, groupPubKey2Bytes, preCommitOutpoint,
 	)
 
 	assertMintSupplyPreCommit(
-		t, *assetStore, batchKey, preCommitBind.OutputIndex, internalKey2,
-		groupPubKey2Bytes, preCommitOutpoint,
+		t, *assetStore, batchKey, preCommitBind.OutputIndex,
+		internalKey2, groupPubKey2Bytes, preCommitOutpoint,
 	)
 }
 
@@ -2110,7 +2124,9 @@ func TestUpdateBatchStateMemoryCoherence(t *testing.T) {
 	ctx := context.Background()
 
 	mintingBatch := tapgarden.RandMintingBatch(t)
-	require.NoError(t, assetStore.CommitMintingBatch(ctx, mintingBatch, tapgarden.MockBindDataForBatch(mintingBatch)))
+	require.NoError(t, assetStore.CommitMintingBatch(
+		ctx, mintingBatch, tapgarden.MockBindDataForBatch(mintingBatch),
+	))
 	require.Equal(
 		t, tapgarden.BatchStatePending, mintingBatch.State(),
 	)
@@ -2155,12 +2171,17 @@ func TestSingletonPreBroadcastBatchConstraint(t *testing.T) {
 
 	// A first Pending batch is fine.
 	first := tapgarden.RandMintingBatch(t)
-	require.NoError(t, assetStore.CommitMintingBatch(ctx, first, tapgarden.MockBindDataForBatch(first)))
+	require.NoError(t, assetStore.CommitMintingBatch(
+		ctx, first, tapgarden.MockBindDataForBatch(first),
+	))
 
 	// A second Pending batch must be rejected: two rows in
 	// BatchStatePending violate the partial unique index.
 	secondPending := tapgarden.RandMintingBatch(t)
-	err := assetStore.CommitMintingBatch(ctx, secondPending, tapgarden.MockBindDataForBatch(secondPending))
+	err := assetStore.CommitMintingBatch(
+		ctx, secondPending,
+		tapgarden.MockBindDataForBatch(secondPending),
+	)
 	require.Error(t, err)
 
 	// Move the first batch to Frozen; it is still in the
@@ -2171,7 +2192,10 @@ func TestSingletonPreBroadcastBatchConstraint(t *testing.T) {
 	))
 
 	pendingWhileFrozen := tapgarden.RandMintingBatch(t)
-	err = assetStore.CommitMintingBatch(ctx, pendingWhileFrozen, tapgarden.MockBindDataForBatch(pendingWhileFrozen))
+	err = assetStore.CommitMintingBatch(
+		ctx, pendingWhileFrozen,
+		tapgarden.MockBindDataForBatch(pendingWhileFrozen),
+	)
 	require.Error(t, err)
 
 	// Move the first batch out of the pre-broadcast set into
@@ -2182,7 +2206,9 @@ func TestSingletonPreBroadcastBatchConstraint(t *testing.T) {
 	))
 
 	third := tapgarden.RandMintingBatch(t)
-	require.NoError(t, assetStore.CommitMintingBatch(ctx, third, tapgarden.MockBindDataForBatch(third)))
+	require.NoError(t, assetStore.CommitMintingBatch(
+		ctx, third, tapgarden.MockBindDataForBatch(third),
+	))
 
 	// And finally: two batches both in Committed must be
 	// permitted -- the constraint targets only the pre-broadcast

tapdb/migrations_test.go

@@ -1435,12 +1435,17 @@ func TestMigration62BackfillSupplyUpdateEventKeys(t *testing.T) {
 	}
 
 	for _, s := range seeds {
-		_, err := db.ExecContext(ctx, `
-			INSERT INTO supply_update_events (
-				group_key, transition_id,
-				update_type_id, event_data
-			) VALUES (?, NULL, ?, ?)
-		`, groupKey, s.typeID, s.data)
+		// EventKey is intentionally nil so the row mimics what a
+		// legacy database holds before migration 62's backfill.
+		_, err := db.InsertSupplyUpdateEvent(
+			ctx, sqlc.InsertSupplyUpdateEventParams{
+				GroupKey:     groupKey,
+				TransitionID: sql.NullInt64{},
+				UpdateTypeID: s.typeID,
+				EventData:    s.data,
+				EventKey:     nil,
+			},
+		)
 		require.NoError(t, err)
 	}
 
@@ -1537,13 +1542,18 @@ func TestMigration62BackfillDedupesLegacyDuplicates(t *testing.T) {
 	require.NoError(t, err)
 
 	// Exactly one row should survive, and its event_key should
-	// match the hash of the duplicated content.
+	// match the hash of the duplicated content. MAX(bytea) is not
+	// defined in Postgres, so fetch count and key separately.
 	var postCount int
-	var survivingKey []byte
 	require.NoError(t, db.QueryRowContext(ctx, `
-		SELECT COUNT(*), MAX(event_key) FROM supply_update_events
-	`).Scan(&postCount, &survivingKey))
+		SELECT COUNT(*) FROM supply_update_events
+	`).Scan(&postCount))
 	require.Equal(t, 1, postCount)
+
+	var survivingKey []byte
+	require.NoError(t, db.QueryRowContext(ctx, `
+		SELECT event_key FROM supply_update_events LIMIT 1
+	`).Scan(&survivingKey))
 	require.Equal(t,
 		supplyUpdateEventKey(groupKey, 0, payload),
 		survivingKey,

tapdb/programmatic_migrations.go

@@ -28,12 +28,12 @@ const (
 	// witnesses.
 	Migration51InsertAssetBurns = 51
 
-	// Migration62BackfillSupplyUpdateEventKeys is the version of the
+	// Migration62BackfillEventKeys is the version of the
 	// programmatic migration that computes the dedup content-hash for
 	// every supply_update_events row that pre-dates the event_key
 	// column. SQLite has no native SHA-256, so the work cannot be
 	// expressed as portable SQL.
-	Migration62BackfillSupplyUpdateEventKeys = 62
+	Migration62BackfillEventKeys = 62
 )
 
 // programmaticMigration is a function type for a function that performs a
@@ -46,9 +46,9 @@ var (
 	// These functions are used to perform additional checks on the
 	// database state that are not fully expressible in SQL.
 	programmaticMigrations = map[uint]programmaticMigration{
-		Migration50ScriptKeyType:                 determineAndAssignScriptKeyType,
-		Migration51InsertAssetBurns:              insertAssetBurns,
-		Migration62BackfillSupplyUpdateEventKeys: backfillSupplyUpdateEventKeys,
+		Migration50ScriptKeyType:     determineAndAssignScriptKeyType,
+		Migration51InsertAssetBurns:  insertAssetBurns,
+		Migration62BackfillEventKeys: backfillSupplyUpdateEventKeys,
 	}
 )
 

tapdb/sqlc/querier.go

@@ -157,10 +157,12 @@ func (h *supplyCommitTestHarness) addTestMintingBatch() ([]byte, int64,
 	// planter state machine, only the supply-commit logic, so the
 	// specific state does not matter as long as it is not
 	// Pending or Frozen.
-	err = db.UpdateMintingBatchState(ctx, sqlc.UpdateMintingBatchStateParams{
-		RawKey:     batchKeyBytes,
-		BatchState: int16(tapgarden.BatchStateFinalized),
-	})
+	err = db.UpdateMintingBatchState(
+		ctx, sqlc.UpdateMintingBatchStateParams{
+			RawKey:     batchKeyBytes,
+			BatchState: int16(tapgarden.BatchStateFinalized),
+		},
+	)
 	require.NoError(h.t, err)
 
 	_, err = db.BindMintingBatchWithTx(
@@ -1537,7 +1539,8 @@ func TestBindDanglingUpdatesToTransition(t *testing.T) {
 
 				eventData := b.Bytes()
 				eventKey := supplyUpdateEventKey(
-					h.groupKeyBytes, updateTypeID, eventData,
+					h.groupKeyBytes, updateTypeID,
+					eventData,
 				)
 
 				rows, err := db.InsertSupplyUpdateEvent(

tapdb/sqlc/supply_commit.sql.go

@@ -300,7 +300,6 @@ func TestCheckSingletonInvariant(t *testing.T) {
 
 	t.Run("error names offending keys and repair tool",
 		func(t *testing.T) {
-
 			a := mkBatch(BatchStatePending)
 			b := mkBatch(BatchStateFrozen)
 
@@ -514,15 +513,12 @@ func TestSeedlingValidateCommitSplit(t *testing.T) {
 			AssetType:         asset.Normal,
 			Amount:            1,
 			SupplyCommitments: supplyCommitments,
-			DelegationKey: fn.None[
-				keychain.KeyDescriptor,
-			](),
+			DelegationKey:     fn.None[keychain.KeyDescriptor](),
 		}
 	}
 
 	t.Run("validate on populated batch leaves it unchanged",
 		func(t *testing.T) {
-
 			batch := RandMintingBatch(
 				t, WithTotalSeedlings(3),
 			)
@@ -547,7 +543,6 @@ func TestSeedlingValidateCommitSplit(t *testing.T) {
 
 	t.Run("commit on empty batch adopts SupplyCommitments",
 		func(t *testing.T) {
-
 			batch := &MintingBatch{}
 
 			candidate := mkCandidate("first-seedling", false)