package storage import ( "bytes" "context" "io" "math" "math/rand" sectorbuilder "github.com/filecoin-project/go-sectorbuilder" "golang.org/x/xerrors" "github.com/filecoin-project/lotus/api" "github.com/filecoin-project/lotus/chain/actors" "github.com/filecoin-project/lotus/chain/types" ) func (m *Miner) pledgeSector(ctx context.Context, sectorID uint64, existingPieceSizes []uint64, sizes ...uint64) ([]Piece, error) { if len(sizes) == 0 { return nil, nil } deals := make([]actors.StorageDealProposal, len(sizes)) for i, size := range sizes { release := m.sb.RateLimit() commP, err := sectorbuilder.GeneratePieceCommitment(io.LimitReader(rand.New(rand.NewSource(42)), int64(size)), size) release() if err != nil { return nil, err } sdp := actors.StorageDealProposal{ PieceRef: commP[:], PieceSize: size, Client: m.worker, Provider: m.maddr, ProposalExpiration: math.MaxUint64, Duration: math.MaxUint64 / 2, // /2 because overflows StoragePricePerEpoch: types.NewInt(0), StorageCollateral: types.NewInt(0), ProposerSignature: nil, } if err := api.SignWith(ctx, m.api.WalletSign, m.worker, &sdp); err != nil { return nil, xerrors.Errorf("signing storage deal failed: ", err) } deals[i] = sdp } params, aerr := actors.SerializeParams(&actors.PublishStorageDealsParams{ Deals: deals, }) if aerr != nil { return nil, xerrors.Errorf("serializing PublishStorageDeals params failed: ", aerr) } smsg, err := m.api.MpoolPushMessage(ctx, &types.Message{ To: actors.StorageMarketAddress, From: m.worker, Value: types.NewInt(0), GasPrice: types.NewInt(0), GasLimit: types.NewInt(1000000), Method: actors.SMAMethods.PublishStorageDeals, Params: params, }) if err != nil { return nil, err } r, err := m.api.StateWaitMsg(ctx, smsg.Cid()) if err != nil { return nil, err } if r.Receipt.ExitCode != 0 { log.Error(xerrors.Errorf("publishing deal failed: exit %d", r.Receipt.ExitCode)) } var resp actors.PublishStorageDealResponse if err := resp.UnmarshalCBOR(bytes.NewReader(r.Receipt.Return)); err != nil { return nil, err } if len(resp.DealIDs) != len(sizes) { return nil, xerrors.New("got unexpected number of DealIDs from PublishStorageDeals") } out := make([]Piece, len(sizes)) for i, size := range sizes { ppi, err := m.sb.AddPiece(size, sectorID, io.LimitReader(rand.New(rand.NewSource(42)), int64(size)), existingPieceSizes) if err != nil { return nil, err } existingPieceSizes = append(existingPieceSizes, size) out[i] = Piece{ DealID: resp.DealIDs[i], Size: ppi.Size, CommP: ppi.CommP[:], } } return out, nil } func (m *Miner) PledgeSector() error { go func() { ctx := context.TODO() // we can't use the context from command which invokes // this, as we run everything here async, and it's cancelled when the // command exits size := sectorbuilder.UserBytesForSectorSize(m.sb.SectorSize()) sid, err := m.sb.AcquireSectorId() if err != nil { log.Errorf("%+v", err) return } pieces, err := m.pledgeSector(ctx, sid, []uint64{}, size) if err != nil { log.Errorf("%+v", err) return } if err := m.newSector(context.TODO(), sid, pieces[0].DealID, pieces[0].ppi()); err != nil { log.Errorf("%+v", err) return } }() return nil }