Merge remote-tracking branch 'origin/testnet/3' into feat/4stage-seal

node/impl/client/client.go

@@ -58,26 +58,26 @@ type API struct {
 	Filestore  dtypes.ClientFilestore `optional:"true"`
 }
 
-func (a *API) ClientStartDeal(ctx context.Context, data cid.Cid, addr address.Address, miner address.Address, epochPrice types.BigInt, blocksDuration uint64) (*cid.Cid, error) {
-	exist, err := a.WalletHas(ctx, addr)
+func (a *API) ClientStartDeal(ctx context.Context, params *api.StartDealParams) (*cid.Cid, error) {
+	exist, err := a.WalletHas(ctx, params.Wallet)
 	if err != nil {
-		return nil, xerrors.Errorf("failed getting addr from wallet: %w", addr)
+		return nil, xerrors.Errorf("failed getting addr from wallet: %w", params.Wallet)
 	}
 	if !exist {
 		return nil, xerrors.Errorf("provided address doesn't exist in wallet")
 	}
 
-	pid, err := a.StateMinerPeerID(ctx, miner, types.EmptyTSK)
+	pid, err := a.StateMinerPeerID(ctx, params.Miner, types.EmptyTSK)
 	if err != nil {
 		return nil, xerrors.Errorf("failed getting peer ID: %w", err)
 	}
 
-	mw, err := a.StateMinerWorker(ctx, miner, types.EmptyTSK)
+	mw, err := a.StateMinerWorker(ctx, params.Miner, types.EmptyTSK)
 	if err != nil {
 		return nil, xerrors.Errorf("failed getting miner worker: %w", err)
 	}
 
-	ssize, err := a.StateMinerSectorSize(ctx, miner, types.EmptyTSK)
+	ssize, err := a.StateMinerSectorSize(ctx, params.Miner, types.EmptyTSK)
 	if err != nil {
 		return nil, xerrors.Errorf("failed checking miners sector size: %w", err)
 	}
@@ -87,22 +87,20 @@ func (a *API) ClientStartDeal(ctx context.Context, data cid.Cid, addr address.Ad
 		return nil, xerrors.Errorf("bad sector size: %w", err)
 	}
 
-	providerInfo := utils.NewStorageProviderInfo(miner, mw, 0, pid)
+	providerInfo := utils.NewStorageProviderInfo(params.Miner, mw, 0, pid)
 	ts, err := a.ChainHead(ctx)
 	if err != nil {
 		return nil, xerrors.Errorf("failed getting chain height: %w", err)
 	}
+
 	result, err := a.SMDealClient.ProposeStorageDeal(
 		ctx,
-		addr,
+		params.Wallet,
 		&providerInfo,
-		&storagemarket.DataRef{
-			TransferType: storagemarket.TTGraphsync,
-			Root:         data,
-		},
+		params.Data,
 		ts.Height()+dealStartBuffer,
-		ts.Height()+dealStartBuffer+abi.ChainEpoch(blocksDuration),
-		epochPrice,
+		ts.Height()+dealStartBuffer+abi.ChainEpoch(params.BlocksDuration),
+		params.EpochPrice,
 		big.Zero(),
 		rt,
 	)
@@ -332,7 +330,7 @@ func (a *API) ClientRetrieve(ctx context.Context, order api.RetrievalOrder, path
 		return xerrors.New("Retrieval Timed Out")
 	case err := <-retrievalResult:
 		if err != nil {
-			return xerrors.Errorf("Retrieve: %w", err)
+			return xerrors.Errorf("RetrieveUnixfs: %w", err)
 		}
 	}
 

node/impl/full/sync.go

@@ -77,7 +77,7 @@ func (a *SyncAPI) SyncSubmitBlock(ctx context.Context, blk *types.BlockMsg) erro
 	}
 
 	// TODO: anything else to do here?
-	return a.PubSub.Publish(build.MessagesTopic, b)
+	return a.PubSub.Publish(build.BlocksTopic, b)
 }
 
 func (a *SyncAPI) SyncIncomingBlocks(ctx context.Context) (<-chan *types.BlockHeader, error) {

node/impl/storminer.go

@@ -4,17 +4,21 @@ import (
 	"context"
 	"encoding/json"
 	"net/http"
+	"os"
 	"strconv"
 
-	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/gorilla/mux"
+	"github.com/ipfs/go-cid"
+	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-address"
+	storagemarket "github.com/filecoin-project/go-fil-markets/storagemarket"
 	"github.com/filecoin-project/go-sectorbuilder"
 	"github.com/filecoin-project/specs-actors/actors/abi"
-	"github.com/gorilla/mux"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/api/apistruct"
+	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/miner"
 	"github.com/filecoin-project/lotus/storage"
 	"github.com/filecoin-project/lotus/storage/sectorblocks"
@@ -27,9 +31,10 @@ type StorageMinerAPI struct {
 	//SectorBuilder       sectorbuilder.Interface
 	SectorBlocks        *sectorblocks.SectorBlocks
 
-	Miner      *storage.Miner
-	BlockMiner *miner.Miner
-	Full       api.FullNode
+	StorageProvider storagemarket.StorageProvider
+	Miner           *storage.Miner
+	BlockMiner      *miner.Miner
+	Full            api.FullNode
 }
 
 func (sm *StorageMinerAPI) ServeRemote(w http.ResponseWriter, r *http.Request) {
@@ -256,4 +261,41 @@ func (sm *StorageMinerAPI) WorkerDone(ctx context.Context, task uint64, res sect
 	return sm.SectorBuilder.TaskDone(ctx, task, res)
 }
 */
+
+func (sm *StorageMinerAPI) MarketImportDealData(ctx context.Context, propCid cid.Cid, path string) error {
+	fi, err := os.Open(path)
+	if err != nil {
+		return xerrors.Errorf("failed to open file: %w", err)
+	}
+	defer fi.Close()
+
+	return sm.StorageProvider.ImportDataForDeal(ctx, propCid, fi)
+}
+
+func (sm *StorageMinerAPI) MarketListDeals(ctx context.Context) ([]storagemarket.StorageDeal, error) {
+	return sm.StorageProvider.ListDeals(ctx)
+}
+
+func (sm *StorageMinerAPI) MarketListIncompleteDeals(ctx context.Context) ([]storagemarket.MinerDeal, error) {
+	return sm.StorageProvider.ListIncompleteDeals()
+}
+
+func (sm *StorageMinerAPI) SetPrice(ctx context.Context, p types.BigInt) error {
+	return sm.StorageProvider.AddAsk(abi.TokenAmount(p), 60*60*24*100) // lasts for 100 days?
+}
+
+func (sm *StorageMinerAPI) DealsList(ctx context.Context) ([]storagemarket.StorageDeal, error) {
+	return sm.StorageProvider.ListDeals(ctx)
+}
+
+func (sm *StorageMinerAPI) DealsImportData(ctx context.Context, deal cid.Cid, fname string) error {
+	fi, err := os.Open(fname)
+	if err != nil {
+		return xerrors.Errorf("failed to open given file: %w", err)
+	}
+	defer fi.Close()
+
+	return sm.StorageProvider.ImportDataForDeal(ctx, deal, fi)
+}
+
 var _ api.StorageMiner = &StorageMinerAPI{}

node/modules/services.go

@@ -71,7 +71,7 @@ func HandleIncomingBlocks(mctx helpers.MetricsCtx, lc fx.Lifecycle, ps *pubsub.P
 func HandleIncomingMessages(mctx helpers.MetricsCtx, lc fx.Lifecycle, ps *pubsub.PubSub, mpool *messagepool.MessagePool) {
 	ctx := helpers.LifecycleCtx(mctx, lc)
 
-	msgsub, err := ps.Subscribe(build.MessagesTopic)
+	msgsub, err := ps.Subscribe(build.BlocksTopic)
 	if err != nil {
 		panic(err)
 	}