Add expected seal duration to custom deal logic, reject deals that start too early

node/builder.go

@@ -326,6 +326,8 @@ func Online() Option {
 			Override(new(dtypes.SetConsiderOfflineRetrievalDealsConfigFunc), modules.NewSetConsiderOfflineRetrievalDealsConfigFunc),
 			Override(new(dtypes.SetSealingDelayFunc), modules.NewSetSealDelayFunc),
 			Override(new(dtypes.GetSealingDelayFunc), modules.NewGetSealDelayFunc),
+			Override(new(dtypes.SetExpectedSealDurationFunc), modules.NewSetExpectedSealDurationFunc),
+			Override(new(dtypes.GetExpectedSealDurationFunc), modules.NewGetExpectedSealDurationFunc),
 		),
 	)
 }

node/config/def.go

@@ -40,6 +40,7 @@ type DealmakingConfig struct {
 	ConsiderOnlineRetrievalDeals  bool
 	ConsiderOfflineRetrievalDeals bool
 	PieceCidBlocklist             []cid.Cid
+	ExpectedSealDuration          Duration
 }
 
 // API contains configs for API endpoint
@@ -132,6 +133,8 @@ func DefaultStorageMiner() *StorageMiner {
 			ConsiderOnlineRetrievalDeals:  true,
 			ConsiderOfflineRetrievalDeals: true,
 			PieceCidBlocklist:             []cid.Cid{},
+			// TODO: It'd be nice to set this based on sector size
+			ExpectedSealDuration: Duration(time.Hour * 12),
 		},
 
 		SealingDelay: Duration(time.Hour),

node/impl/storminer.go

@@ -56,6 +56,8 @@ type StorageMinerAPI struct {
 	SetConsiderOfflineRetrievalDealsConfigFunc dtypes.SetConsiderOfflineRetrievalDealsConfigFunc
 	SetSealingDelayFunc                        dtypes.SetSealingDelayFunc
 	GetSealingDelayFunc                        dtypes.GetSealingDelayFunc
+	GetExpectedSealDurationFunc                dtypes.GetExpectedSealDurationFunc
+	SetExpectedSealDurationFunc                dtypes.SetExpectedSealDurationFunc
 }
 
 func (sm *StorageMinerAPI) ServeRemote(w http.ResponseWriter, r *http.Request) {
@@ -192,6 +194,14 @@ func (sm *StorageMinerAPI) SectorGetSealDelay(ctx context.Context) (time.Duratio
 	return sm.GetSealingDelayFunc()
 }
 
+func (sm *StorageMinerAPI) SectorSetExpectedSealDuration(ctx context.Context, delay time.Duration) error {
+	return sm.SetExpectedSealDurationFunc(delay)
+}
+
+func (sm *StorageMinerAPI) SectorGetExpectedSealDuration(ctx context.Context) (time.Duration, error) {
+	return sm.GetExpectedSealDurationFunc()
+}
+
 func (sm *StorageMinerAPI) SectorsUpdate(ctx context.Context, id abi.SectorNumber, state api.SectorState) error {
 	return sm.Miner.ForceSectorState(ctx, id, sealing.SectorState(state))
 }
@@ -282,6 +292,14 @@ func (sm *StorageMinerAPI) DealsSetConsiderOfflineRetrievalDeals(ctx context.Con
 	return sm.SetConsiderOfflineRetrievalDealsConfigFunc(b)
 }
 
+func (sm *StorageMinerAPI) DealsGetExpectedSealDurationFunc(ctx context.Context) (time.Duration, error) {
+	return sm.GetExpectedSealDurationFunc()
+}
+
+func (sm *StorageMinerAPI) DealsSetExpectedSealDurationFunc(ctx context.Context, d time.Duration) error {
+	return sm.SetExpectedSealDurationFunc(d)
+}
+
 func (sm *StorageMinerAPI) DealsImportData(ctx context.Context, deal cid.Cid, fname string) error {
 	fi, err := os.Open(fname)
 	if err != nil {

node/modules/dtypes/miner.go

@@ -56,3 +56,11 @@ type SetSealingDelayFunc func(time.Duration) error
 
 // GetSealingDelay returns how long a sector waits for more deals before sealing begins.
 type GetSealingDelayFunc func() (time.Duration, error)
+
+// SetExpectedSealDurationFunc is a function which is used to set how long sealing is expected to take.
+// Deals that would need to start earlier than this duration will be rejected.
+type SetExpectedSealDurationFunc func(time.Duration) error
+
+// GetExpectedSealDurationFunc is a function which reads from miner
+// too determine how long sealing is expected to take
+type GetExpectedSealDurationFunc func() (time.Duration, error)

node/modules/storageminer.go

@@ -335,7 +335,19 @@ func NewStorageAsk(ctx helpers.MetricsCtx, fapi lapi.FullNode, ds dtypes.Metadat
 	return storedAsk, nil
 }
 
-func StorageProvider(minerAddress dtypes.MinerAddress, ffiConfig *ffiwrapper.Config, storedAsk *storedask.StoredAsk, h host.Host, ds dtypes.MetadataDS, ibs dtypes.StagingBlockstore, r repo.LockedRepo, pieceStore dtypes.ProviderPieceStore, dataTransfer dtypes.ProviderDataTransfer, spn storagemarket.StorageProviderNode, onlineOk dtypes.ConsiderOnlineStorageDealsConfigFunc, offlineOk dtypes.ConsiderOfflineStorageDealsConfigFunc, blocklistFunc dtypes.StorageDealPieceCidBlocklistConfigFunc) (storagemarket.StorageProvider, error) {
+func StorageProvider(minerAddress dtypes.MinerAddress,
+	ffiConfig *ffiwrapper.Config,
+	storedAsk *storedask.StoredAsk,
+	h host.Host, ds dtypes.MetadataDS,
+	ibs dtypes.StagingBlockstore,
+	r repo.LockedRepo,
+	pieceStore dtypes.ProviderPieceStore,
+	dataTransfer dtypes.ProviderDataTransfer,
+	spn storagemarket.StorageProviderNode,
+	onlineOk dtypes.ConsiderOnlineStorageDealsConfigFunc,
+	offlineOk dtypes.ConsiderOfflineStorageDealsConfigFunc,
+	blocklistFunc dtypes.StorageDealPieceCidBlocklistConfigFunc,
+	expectedSealTimeFunc dtypes.GetExpectedSealDurationFunc) (storagemarket.StorageProvider, error) {
 	net := smnet.NewFromLibp2pHost(h)
 	store, err := piecefilestore.NewLocalFileStore(piecefilestore.OsPath(r.Path()))
 	if err != nil {
@@ -375,6 +387,22 @@ func StorageProvider(minerAddress dtypes.MinerAddress, ffiConfig *ffiwrapper.Con
 			}
 		}
 
+		sealDuration, err := expectedSealTimeFunc()
+		if err != nil {
+			return false, "miner error", err
+		}
+
+		sealEpochs := sealDuration / (time.Duration(build.BlockDelaySecs) * time.Second)
+		_, ht, err := spn.GetChainHead(ctx)
+		if err != nil {
+			return false, "failed to get chain head", err
+		}
+		earliest := abi.ChainEpoch(sealEpochs) + ht
+		if deal.Proposal.StartEpoch < earliest {
+			log.Warnf("proposed deal would start before sealing can be completed; rejecting storage deal proposal from client: %s", deal.Proposal.PieceCID, deal.Client.String())
+			return false, fmt.Sprintf("cannot seal a sector before %s", deal.Proposal.StartEpoch), nil
+		}
+
 		return true, "", nil
 	})
 
@@ -563,6 +591,24 @@ func NewGetSealDelayFunc(r repo.LockedRepo) (dtypes.GetSealingDelayFunc, error)
 	}, nil
 }
 
+func NewSetExpectedSealDurationFunc(r repo.LockedRepo) (dtypes.SetExpectedSealDurationFunc, error) {
+	return func(delay time.Duration) (err error) {
+		err = mutateCfg(r, func(cfg *config.StorageMiner) {
+			cfg.Dealmaking.ExpectedSealDuration = config.Duration(delay)
+		})
+		return
+	}, nil
+}
+
+func NewGetExpectedSealDurationFunc(r repo.LockedRepo) (dtypes.GetExpectedSealDurationFunc, error) {
+	return func() (out time.Duration, err error) {
+		err = readCfg(r, func(cfg *config.StorageMiner) {
+			out = time.Duration(cfg.Dealmaking.ExpectedSealDuration)
+		})
+		return
+	}, nil
+}
+
 func readCfg(r repo.LockedRepo, accessor func(*config.StorageMiner)) error {
 	raw, err := r.Config()
 	if err != nil {