add Deal.WalletID, decouple from Actor FK

Deal.ClientID remains a plain string for on-chain deal matching (Key())
but no longer has a FK constraint to the actors table. New WalletID
*uint FK points to wallets.id, letting PDP deals reference the
originating wallet even when no f0 actor exists yet.

- model: add WalletID + Wallet FK on Deal, remove Actor FK
- migrate: backfill wallet_id from client_id→actor→wallet, drop
  fk_deals_actor constraint
- all deal creation sites set WalletID (dealpusher, pdp_schedule,
  send-manual, dealtracker, eventprocessor)
- datacap query uses wallet_id instead of client_id
- pdp_schedule no longer requires actor to exist for PDP deals

Author: parkan

client/swagger/models/model_deal.go

@@ -140,6 +140,7 @@ func (DefaultHandler) SendManualHandler(
 		AnnounceToIPNI: request.IPNI,
 		StartDelay:     startDelay,
 		Duration:       duration,
+		WalletID:       &walletObj.ID,
 	}
 
 	// resolve actor lazily — only makes RPC call if ActorID not yet linked

docs/swagger/docs.go

@@ -3,7 +3,6 @@ package deal
 import (
 	"context"
 	"testing"
-	"time"
 
 	"github.com/data-preservation-programs/singularity/handler/handlererror"
 	"github.com/data-preservation-programs/singularity/model"
@@ -160,19 +159,13 @@ func TestSendManualHandler(t *testing.T) {
 		createTestWalletAndActor(t, db, true)
 
 		mockDealMaker := new(MockDealMaker)
-		mockDealMaker.On("MakeDeal", mock.Anything, actor, mock.Anything, replication.DealConfig{
-			Provider:        proposal.ProviderID,
-			StartDelay:      24 * time.Hour,
-			Duration:        2400 * time.Hour,
-			Verified:        proposal.Verified,
-			HTTPHeaders:     map[string]string{"a": "b"},
-			URLTemplate:     proposal.URLTemplate,
-			KeepUnsealed:    proposal.KeepUnsealed,
-			AnnounceToIPNI:  proposal.IPNI,
-			PricePerDeal:    proposal.PricePerDeal,
-			PricePerGB:      proposal.PricePerGB,
-			PricePerGBEpoch: proposal.PricePerGBEpoch,
-		}).Return(&model.Deal{}, nil)
+		mockDealMaker.On("MakeDeal", mock.Anything, actor, mock.Anything,
+			mock.MatchedBy(func(dc replication.DealConfig) bool {
+				return dc.Provider == proposal.ProviderID &&
+					dc.Verified == proposal.Verified &&
+					dc.WalletID != nil
+			}),
+		).Return(&model.Deal{}, nil)
 		// lotusClient is nil — GetOrCreateActor won't call lotus because ActorID is already set
 		resp, err := Default.SendManualHandler(ctx, db, nil, nil, mockDealMaker, proposal)
 		mockDealMaker.AssertExpectations(t)

docs/swagger/swagger.json

@@ -77,13 +77,10 @@ func TestGetFileDealsHandler(t *testing.T) {
 
 		deals := []model.Deal{{
 			PieceCID: model.CID(testCid1),
-			Actor:    &model.Actor{},
 		}, {
 			PieceCID: model.CID(testCid2),
-			Actor:    &model.Actor{},
 		}, {
 			PieceCID: model.CID(testCid2),
-			Actor:    &model.Actor{},
 		}}
 		err = db.Create(deals).Error
 		require.NoError(t, err)

docs/swagger/swagger.yaml

@@ -144,7 +144,6 @@ func TestRetrieveFileHandler(t *testing.T) {
 						State:    model.DealActive,
 						PieceCID: model.CID(testCid),
 						Provider: "apples" + strconv.Itoa(i),
-						Actor:    &model.Actor{},
 					}
 					err = db.Create(&deal).Error
 					require.NoError(t, err)
@@ -158,7 +157,6 @@ func TestRetrieveFileHandler(t *testing.T) {
 						State:    state,
 						PieceCID: model.CID(testCid),
 						Provider: "oranges" + strconv.Itoa(i),
-						Actor:    &model.Actor{},
 					}
 					err = db.Create(&deal).Error
 					require.NoError(t, err)
@@ -489,7 +487,6 @@ func BenchmarkFilecoinRetrieve(b *testing.B) {
 			State:    model.DealActive,
 			PieceCID: model.CID(testCid),
 			Provider: "apples" + strconv.Itoa(i),
-			Actor:    &model.Actor{},
 		}
 		err = db.Create(&deal).Error
 		require.NoError(b, err)
@@ -502,7 +499,6 @@ func BenchmarkFilecoinRetrieve(b *testing.B) {
 			State:    state,
 			PieceCID: model.CID(testCid),
 			Provider: "oranges" + strconv.Itoa(i),
-			Actor:    &model.Actor{},
 		}
 		err = db.Create(&deal).Error
 		require.NoError(b, err)

handler/deal/send-manual.go

@@ -124,6 +124,16 @@ func AutoMigrate(db *gorm.DB) error {
 		return errors.Wrap(err, "failed to infer deal types")
 	}
 
+	// Drop legacy fk_deals_actor constraint (Deal.ClientID no longer FKs to Actor)
+	if err := dropDealActorFK(db); err != nil {
+		return errors.Wrap(err, "failed to drop deal-actor FK")
+	}
+
+	// Backfill wallet_id for deals that predate the column
+	if err := backfillDealWalletID(db); err != nil {
+		return errors.Wrap(err, "failed to backfill deal wallet IDs")
+	}
+
 	return nil
 }
 
@@ -344,6 +354,92 @@ func inferDealTypes(db *gorm.DB) error {
 	return nil
 }
 
+// dropDealActorFK removes the legacy fk_deals_actor constraint if it exists.
+// Deal.ClientID is now a plain string (no FK to actors table).
+func dropDealActorFK(db *gorm.DB) error {
+	dialect := db.Dialector.Name()
+	if dialect == "sqlite" {
+		return nil
+	}
+
+	constraint := "fk_deals_actor"
+	var exists bool
+
+	if dialect == "postgres" {
+		err := db.Raw(`
+			SELECT EXISTS (
+				SELECT 1 FROM information_schema.table_constraints
+				WHERE table_name = 'deals' AND constraint_name = ?
+			)`, constraint).Scan(&exists).Error
+		if err != nil {
+			return errors.Wrapf(err, "failed to check constraint %s", constraint)
+		}
+	} else if dialect == "mysql" {
+		err := db.Raw(`
+			SELECT COUNT(*) > 0 FROM information_schema.TABLE_CONSTRAINTS
+			WHERE TABLE_NAME = 'deals' AND CONSTRAINT_NAME = ?
+		`, constraint).Scan(&exists).Error
+		if err != nil {
+			return errors.Wrapf(err, "failed to check constraint %s", constraint)
+		}
+	}
+
+	if !exists {
+		return nil
+	}
+
+	logger.Infow("dropping legacy deal-actor FK constraint", "constraint", constraint)
+	if dialect == "postgres" {
+		return db.Exec(`ALTER TABLE deals DROP CONSTRAINT ` + constraint).Error
+	}
+	// mysql
+	return db.Exec(`ALTER TABLE deals DROP FOREIGN KEY ` + constraint).Error
+}
+
+// backfillDealWalletID sets wallet_id for existing deals that have a client_id
+// matching an actor linked to a wallet. idempotent — only touches NULL wallet_id rows.
+func backfillDealWalletID(db *gorm.DB) error {
+	var count int64
+	err := db.Raw(`SELECT COUNT(*) FROM deals WHERE wallet_id IS NULL AND client_id != ''`).Scan(&count).Error
+	if err != nil {
+		logger.Debugw("skipping wallet_id backfill", "error", err)
+		return nil
+	}
+	if count == 0 {
+		return nil
+	}
+
+	logger.Infow("backfilling deal wallet_id from client_id → actor → wallet", "count", count)
+
+	dialect := db.Dialector.Name()
+	var query string
+	if dialect == "sqlite" {
+		query = `
+			UPDATE deals SET wallet_id = (
+				SELECT w.id FROM wallets w
+				WHERE w.actor_id = deals.client_id
+				LIMIT 1
+			) WHERE wallet_id IS NULL AND client_id != ''
+			AND EXISTS (SELECT 1 FROM wallets w WHERE w.actor_id = deals.client_id)`
+	} else {
+		query = `
+			UPDATE deals d
+			SET wallet_id = (
+				SELECT w.id FROM wallets w
+				WHERE w.actor_id = d.client_id
+				LIMIT 1
+			) WHERE d.wallet_id IS NULL AND d.client_id != ''
+			AND EXISTS (SELECT 1 FROM wallets w WHERE w.actor_id = d.client_id)`
+	}
+
+	result := db.Exec(query)
+	if result.Error != nil {
+		return errors.Wrap(result.Error, "failed to backfill wallet_id")
+	}
+	logger.Infow("backfilled deal wallet_id", "updated", result.RowsAffected)
+	return nil
+}
+
 // DropAll removes all tables specified in the Tables slice from the database.
 //
 // This function is typically used during development or testing where a clean database

handler/deal/send-manual_test.go

@@ -123,7 +123,8 @@ type Deal struct {
 	ScheduleID *ScheduleID `json:"scheduleId"                                         table:"verbose"`
 	Schedule   *Schedule   `gorm:"foreignKey:ScheduleID;constraint:OnDelete:SET NULL" json:"schedule,omitempty" swaggerignore:"true" table:"expand"`
 	ClientID   string      `gorm:"index:idx_pending"                                  json:"clientId"`
-	Actor      *Actor      `gorm:"foreignKey:ClientID;constraint:OnDelete:SET NULL"   json:"actor,omitempty"   swaggerignore:"true" table:"expand"`
+	WalletID   *uint       `gorm:"index:idx_deal_wallet"                              json:"walletId,omitempty"  table:"verbose"`
+	Wallet     *Wallet     `gorm:"foreignKey:WalletID;constraint:OnDelete:SET NULL"   json:"wallet,omitempty"    swaggerignore:"true" table:"expand"`
 }
 
 // Key returns a mostly unique key to match deal from locally proposed deals and deals from the chain.