305 lines
9.2 KiB
Go
305 lines
9.2 KiB
Go
package sealing
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"net/url"
|
|
|
|
"github.com/ipfs/go-cid"
|
|
"github.com/ipfs/go-datastore"
|
|
"github.com/multiformats/go-multihash"
|
|
"golang.org/x/xerrors"
|
|
|
|
"github.com/filecoin-project/go-address"
|
|
"github.com/filecoin-project/go-state-types/abi"
|
|
"github.com/filecoin-project/go-state-types/crypto"
|
|
"github.com/filecoin-project/go-state-types/proof"
|
|
"github.com/filecoin-project/go-statemachine"
|
|
|
|
"github.com/filecoin-project/lotus/api"
|
|
"github.com/filecoin-project/lotus/storage/sealer/storiface"
|
|
)
|
|
|
|
func (m *Sealing) Receive(ctx context.Context, meta api.RemoteSectorMeta) error {
|
|
m.inputLk.Lock()
|
|
defer m.inputLk.Unlock()
|
|
|
|
si, err := m.checkSectorMeta(ctx, meta)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
exists, err := m.sectors.Has(uint64(meta.Sector.Number))
|
|
if err != nil {
|
|
return xerrors.Errorf("checking if sector exists: %w", err)
|
|
}
|
|
if exists {
|
|
return xerrors.Errorf("sector %d state already exists", meta.Sector.Number)
|
|
}
|
|
|
|
err = m.sectors.Send(uint64(meta.Sector.Number), SectorReceive{
|
|
State: si,
|
|
})
|
|
if err != nil {
|
|
return xerrors.Errorf("receiving sector: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (m *Sealing) checkSectorMeta(ctx context.Context, meta api.RemoteSectorMeta) (SectorInfo, error) {
|
|
{
|
|
mid, err := address.IDFromAddress(m.maddr)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
if meta.Sector.Miner != abi.ActorID(mid) {
|
|
return SectorInfo{}, xerrors.Errorf("sector for wrong actor - expected actor id %d, sector was for actor %d", mid, meta.Sector.Miner)
|
|
}
|
|
}
|
|
|
|
{
|
|
// initial sanity check, doesn't prevent races
|
|
_, err := m.GetSectorInfo(meta.Sector.Number)
|
|
if err != nil && !xerrors.Is(err, datastore.ErrNotFound) {
|
|
return SectorInfo{}, err
|
|
}
|
|
if err == nil {
|
|
return SectorInfo{}, xerrors.Errorf("sector with ID %d already exists in the sealing pipeline", meta.Sector.Number)
|
|
}
|
|
}
|
|
|
|
{
|
|
spt, err := m.currentSealProof(ctx)
|
|
if err != nil {
|
|
return SectorInfo{}, err
|
|
}
|
|
|
|
if meta.Type != spt {
|
|
return SectorInfo{}, xerrors.Errorf("sector seal proof type doesn't match current seal proof type (%d!=%d)", meta.Type, spt)
|
|
}
|
|
}
|
|
|
|
ts, err := m.Api.ChainHead(ctx)
|
|
if err != nil {
|
|
return SectorInfo{}, xerrors.Errorf("getting chain head: %w", err)
|
|
}
|
|
|
|
var info SectorInfo
|
|
var validatePoRep bool
|
|
|
|
switch SectorState(meta.State) {
|
|
case Proving, Available:
|
|
if meta.CommitMessage != nil {
|
|
if err := checkMessagePrefix(*meta.CommitMessage); err != nil {
|
|
return SectorInfo{}, xerrors.Errorf("commit message prefix: %w", err)
|
|
}
|
|
|
|
info.CommitMessage = meta.CommitMessage
|
|
}
|
|
|
|
fallthrough
|
|
case SubmitCommit:
|
|
if meta.PreCommitDeposit == nil {
|
|
return SectorInfo{}, xerrors.Errorf("sector PreCommitDeposit was null")
|
|
}
|
|
|
|
info.PreCommitDeposit = *meta.PreCommitDeposit
|
|
info.PreCommitTipSet = meta.PreCommitTipSet
|
|
if info.PreCommitMessage != nil {
|
|
if err := checkMessagePrefix(*meta.PreCommitMessage); err != nil {
|
|
return SectorInfo{}, xerrors.Errorf("commit message prefix: %w", err)
|
|
}
|
|
info.PreCommitMessage = meta.PreCommitMessage
|
|
}
|
|
|
|
// check provided seed
|
|
if len(meta.SeedValue) != abi.RandomnessLength {
|
|
return SectorInfo{}, xerrors.Errorf("seed randomness had wrong length %d", len(meta.SeedValue))
|
|
}
|
|
|
|
maddrBuf := new(bytes.Buffer)
|
|
if err := m.maddr.MarshalCBOR(maddrBuf); err != nil {
|
|
return SectorInfo{}, xerrors.Errorf("marshal miner address for seed check: %w", err)
|
|
}
|
|
rand, err := m.Api.StateGetRandomnessFromBeacon(ctx, crypto.DomainSeparationTag_InteractiveSealChallengeSeed, meta.SeedEpoch, maddrBuf.Bytes(), ts.Key())
|
|
if err != nil {
|
|
return SectorInfo{}, xerrors.Errorf("generating check seed: %w", err)
|
|
}
|
|
if !bytes.Equal(rand, meta.SeedValue) {
|
|
return SectorInfo{}, xerrors.Errorf("provided(%x) and generated(%x) seeds differ", meta.SeedValue, rand)
|
|
}
|
|
|
|
info.SeedValue = meta.SeedValue
|
|
info.SeedEpoch = meta.SeedEpoch
|
|
|
|
info.Proof = meta.CommitProof
|
|
validatePoRep = true
|
|
|
|
fallthrough
|
|
case PreCommitting:
|
|
// check provided ticket
|
|
if len(meta.TicketValue) != abi.RandomnessLength {
|
|
return SectorInfo{}, xerrors.Errorf("ticket randomness had wrong length %d", len(meta.TicketValue))
|
|
}
|
|
|
|
maddrBuf := new(bytes.Buffer)
|
|
if err := m.maddr.MarshalCBOR(maddrBuf); err != nil {
|
|
return SectorInfo{}, xerrors.Errorf("marshal miner address for ticket check: %w", err)
|
|
}
|
|
rand, err := m.Api.StateGetRandomnessFromTickets(ctx, crypto.DomainSeparationTag_SealRandomness, meta.TicketEpoch, maddrBuf.Bytes(), ts.Key())
|
|
if err != nil {
|
|
return SectorInfo{}, xerrors.Errorf("generating check ticket: %w", err)
|
|
}
|
|
if !bytes.Equal(rand, meta.TicketValue) {
|
|
return SectorInfo{}, xerrors.Errorf("provided(%x) and generated(%x) tickets differ", meta.TicketValue, rand)
|
|
}
|
|
|
|
info.TicketValue = meta.TicketValue
|
|
info.TicketEpoch = meta.TicketEpoch
|
|
|
|
info.PreCommit1Out = meta.PreCommit1Out
|
|
|
|
// check CommD/R
|
|
if meta.CommD == nil || meta.CommR == nil {
|
|
return SectorInfo{}, xerrors.Errorf("both CommR/CommD cids need to be set for sectors in PreCommitting and later states")
|
|
}
|
|
|
|
dp := meta.CommD.Prefix()
|
|
if dp.Version != 1 || dp.Codec != cid.FilCommitmentUnsealed || dp.MhType != multihash.SHA2_256_TRUNC254_PADDED || dp.MhLength != 32 {
|
|
return SectorInfo{}, xerrors.Errorf("CommD cid has wrong prefix")
|
|
}
|
|
|
|
rp := meta.CommR.Prefix()
|
|
if rp.Version != 1 || rp.Codec != cid.FilCommitmentSealed || rp.MhType != multihash.POSEIDON_BLS12_381_A1_FC1 || rp.MhLength != 32 {
|
|
return SectorInfo{}, xerrors.Errorf("CommR cid has wrong prefix")
|
|
}
|
|
|
|
info.CommD = meta.CommD
|
|
info.CommR = meta.CommR
|
|
|
|
if meta.DataSealed == nil {
|
|
return SectorInfo{}, xerrors.Errorf("expected DataSealed to be set")
|
|
}
|
|
if meta.DataCache == nil {
|
|
return SectorInfo{}, xerrors.Errorf("expected DataCache to be set")
|
|
}
|
|
info.RemoteDataSealed = meta.DataSealed // todo make head requests to check?
|
|
info.RemoteDataCache = meta.DataCache
|
|
|
|
if meta.RemoteCommit1Endpoint != "" {
|
|
// validate the url
|
|
if _, err := url.Parse(meta.RemoteCommit1Endpoint); err != nil {
|
|
return SectorInfo{}, xerrors.Errorf("parsing remote c1 endpoint url: %w", err)
|
|
}
|
|
|
|
info.RemoteCommit1Endpoint = meta.RemoteCommit1Endpoint
|
|
}
|
|
|
|
if meta.RemoteCommit2Endpoint != "" {
|
|
// validate the url
|
|
if _, err := url.Parse(meta.RemoteCommit2Endpoint); err != nil {
|
|
return SectorInfo{}, xerrors.Errorf("parsing remote c2 endpoint url: %w", err)
|
|
}
|
|
|
|
info.RemoteCommit2Endpoint = meta.RemoteCommit2Endpoint
|
|
}
|
|
|
|
// If we get a sector after PC2, and remote C1 endpoint is set, assume that we're getting finalized sector data
|
|
if info.RemoteCommit1Endpoint != "" {
|
|
info.RemoteDataFinalized = true
|
|
}
|
|
|
|
fallthrough
|
|
case GetTicket, Packing:
|
|
info.Return = ReturnState(meta.State)
|
|
info.State = ReceiveSector
|
|
|
|
info.SectorNumber = meta.Sector.Number
|
|
info.Pieces = meta.Pieces
|
|
info.SectorType = meta.Type
|
|
|
|
if meta.RemoteSealingDoneEndpoint != "" {
|
|
// validate the url
|
|
if _, err := url.Parse(meta.RemoteSealingDoneEndpoint); err != nil {
|
|
return SectorInfo{}, xerrors.Errorf("parsing remote sealing-done endpoint url: %w", err)
|
|
}
|
|
|
|
info.RemoteSealingDoneEndpoint = meta.RemoteSealingDoneEndpoint
|
|
}
|
|
|
|
if err := checkPieces(ctx, m.maddr, meta.Sector.Number, meta.Pieces, m.Api, false); err != nil {
|
|
return SectorInfo{}, xerrors.Errorf("checking pieces: %w", err)
|
|
}
|
|
|
|
if meta.DataUnsealed == nil {
|
|
return SectorInfo{}, xerrors.Errorf("expected DataUnsealed to be set")
|
|
}
|
|
info.RemoteDataUnsealed = meta.DataUnsealed
|
|
|
|
// some late checks which require previous checks
|
|
if validatePoRep {
|
|
ok, err := m.verif.VerifySeal(proof.SealVerifyInfo{
|
|
SealProof: meta.Type,
|
|
SectorID: meta.Sector,
|
|
DealIDs: nil,
|
|
Randomness: meta.TicketValue,
|
|
InteractiveRandomness: meta.SeedValue,
|
|
Proof: meta.CommitProof,
|
|
SealedCID: *meta.CommR,
|
|
UnsealedCID: *meta.CommD,
|
|
})
|
|
if err != nil {
|
|
return SectorInfo{}, xerrors.Errorf("validating seal proof: %w", err)
|
|
}
|
|
if !ok {
|
|
return SectorInfo{}, xerrors.Errorf("seal proof invalid")
|
|
}
|
|
}
|
|
|
|
return info, nil
|
|
default:
|
|
return SectorInfo{}, xerrors.Errorf("imported sector State in not supported")
|
|
}
|
|
}
|
|
|
|
func (m *Sealing) handleReceiveSector(ctx statemachine.Context, sector SectorInfo) error {
|
|
toFetch := map[storiface.SectorFileType]storiface.SectorLocation{}
|
|
|
|
for fileType, data := range map[storiface.SectorFileType]*storiface.SectorLocation{
|
|
storiface.FTUnsealed: sector.RemoteDataUnsealed,
|
|
storiface.FTSealed: sector.RemoteDataSealed,
|
|
storiface.FTCache: sector.RemoteDataCache,
|
|
} {
|
|
if data == nil {
|
|
continue
|
|
}
|
|
|
|
if data.Local {
|
|
// todo check exists
|
|
continue
|
|
}
|
|
|
|
toFetch[fileType] = *data
|
|
}
|
|
|
|
if len(toFetch) > 0 {
|
|
if err := m.sealer.DownloadSectorData(ctx.Context(), m.minerSector(sector.SectorType, sector.SectorNumber), sector.RemoteDataFinalized, toFetch); err != nil {
|
|
return xerrors.Errorf("downloading sector data: %w", err) // todo send err event
|
|
}
|
|
}
|
|
|
|
// todo data checks?
|
|
|
|
return ctx.Send(SectorReceived{})
|
|
}
|
|
|
|
func checkMessagePrefix(c cid.Cid) error {
|
|
p := c.Prefix()
|
|
if p.Version != 1 || p.MhLength != 32 || p.MhType != multihash.BLAKE2B_MIN+31 || p.Codec != cid.DagCBOR {
|
|
return xerrors.New("invalid message prefix")
|
|
}
|
|
return nil
|
|
}
|