150 lines
4.6 KiB
Go
150 lines
4.6 KiB
Go
//go:build cgo
|
|
// +build cgo
|
|
|
|
package ffiwrapper
|
|
|
|
import (
|
|
"context"
|
|
|
|
proof7 "github.com/filecoin-project/specs-actors/v7/actors/runtime/proof"
|
|
|
|
"go.opencensus.io/trace"
|
|
"golang.org/x/xerrors"
|
|
|
|
ffi "github.com/filecoin-project/filecoin-ffi"
|
|
"github.com/filecoin-project/go-state-types/abi"
|
|
proof5 "github.com/filecoin-project/specs-actors/v5/actors/runtime/proof"
|
|
"github.com/filecoin-project/specs-storage/storage"
|
|
|
|
"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
|
|
)
|
|
|
|
func (sb *Sealer) GenerateWinningPoSt(ctx context.Context, minerID abi.ActorID, sectorInfo []proof5.SectorInfo, randomness abi.PoStRandomness) ([]proof5.PoStProof, error) {
|
|
randomness[31] &= 0x3f
|
|
privsectors, skipped, done, err := sb.pubSectorToPriv(ctx, minerID, sectorInfo, nil, abi.RegisteredSealProof.RegisteredWinningPoStProof) // TODO: FAULTS?
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer done()
|
|
if len(skipped) > 0 {
|
|
return nil, xerrors.Errorf("pubSectorToPriv skipped sectors: %+v", skipped)
|
|
}
|
|
|
|
return ffi.GenerateWinningPoSt(minerID, privsectors, randomness)
|
|
}
|
|
|
|
func (sb *Sealer) GenerateWindowPoSt(ctx context.Context, minerID abi.ActorID, sectorInfo []proof5.SectorInfo, randomness abi.PoStRandomness) ([]proof5.PoStProof, []abi.SectorID, error) {
|
|
randomness[31] &= 0x3f
|
|
privsectors, skipped, done, err := sb.pubSectorToPriv(ctx, minerID, sectorInfo, nil, abi.RegisteredSealProof.RegisteredWindowPoStProof)
|
|
if err != nil {
|
|
return nil, nil, xerrors.Errorf("gathering sector info: %w", err)
|
|
}
|
|
defer done()
|
|
|
|
if len(skipped) > 0 {
|
|
return nil, skipped, xerrors.Errorf("pubSectorToPriv skipped some sectors")
|
|
}
|
|
|
|
proof, faulty, err := ffi.GenerateWindowPoSt(minerID, privsectors, randomness)
|
|
|
|
var faultyIDs []abi.SectorID
|
|
for _, f := range faulty {
|
|
faultyIDs = append(faultyIDs, abi.SectorID{
|
|
Miner: minerID,
|
|
Number: f,
|
|
})
|
|
}
|
|
|
|
return proof, faultyIDs, err
|
|
}
|
|
|
|
func (sb *Sealer) pubSectorToPriv(ctx context.Context, mid abi.ActorID, sectorInfo []proof5.SectorInfo, faults []abi.SectorNumber, rpt func(abi.RegisteredSealProof) (abi.RegisteredPoStProof, error)) (ffi.SortedPrivateSectorInfo, []abi.SectorID, func(), error) {
|
|
fmap := map[abi.SectorNumber]struct{}{}
|
|
for _, fault := range faults {
|
|
fmap[fault] = struct{}{}
|
|
}
|
|
|
|
var doneFuncs []func()
|
|
done := func() {
|
|
for _, df := range doneFuncs {
|
|
df()
|
|
}
|
|
}
|
|
|
|
var skipped []abi.SectorID
|
|
var out []ffi.PrivateSectorInfo
|
|
for _, s := range sectorInfo {
|
|
if _, faulty := fmap[s.SectorNumber]; faulty {
|
|
continue
|
|
}
|
|
|
|
sid := storage.SectorRef{
|
|
ID: abi.SectorID{Miner: mid, Number: s.SectorNumber},
|
|
ProofType: s.SealProof,
|
|
}
|
|
|
|
paths, d, err := sb.sectors.AcquireSector(ctx, sid, storiface.FTCache|storiface.FTSealed, 0, storiface.PathStorage)
|
|
if err != nil {
|
|
log.Warnw("failed to acquire sector, skipping", "sector", sid.ID, "error", err)
|
|
skipped = append(skipped, sid.ID)
|
|
continue
|
|
}
|
|
doneFuncs = append(doneFuncs, d)
|
|
|
|
postProofType, err := rpt(s.SealProof)
|
|
if err != nil {
|
|
done()
|
|
return ffi.SortedPrivateSectorInfo{}, nil, nil, xerrors.Errorf("acquiring registered PoSt proof from sector info %+v: %w", s, err)
|
|
}
|
|
|
|
out = append(out, ffi.PrivateSectorInfo{
|
|
CacheDirPath: paths.Cache,
|
|
PoStProofType: postProofType,
|
|
SealedSectorPath: paths.Sealed,
|
|
SectorInfo: s,
|
|
})
|
|
}
|
|
|
|
return ffi.NewSortedPrivateSectorInfo(out...), skipped, done, nil
|
|
}
|
|
|
|
var _ Verifier = ProofVerifier
|
|
|
|
type proofVerifier struct{}
|
|
|
|
var ProofVerifier = proofVerifier{}
|
|
|
|
func (proofVerifier) VerifySeal(info proof5.SealVerifyInfo) (bool, error) {
|
|
return ffi.VerifySeal(info)
|
|
}
|
|
|
|
func (proofVerifier) VerifyAggregateSeals(aggregate proof5.AggregateSealVerifyProofAndInfos) (bool, error) {
|
|
return ffi.VerifyAggregateSeals(aggregate)
|
|
}
|
|
|
|
func (proofVerifier) VerifyReplicaUpdate(update proof7.ReplicaUpdateInfo) (bool, error) {
|
|
//TODO: do the thing
|
|
return false, nil
|
|
}
|
|
|
|
func (proofVerifier) VerifyWinningPoSt(ctx context.Context, info proof5.WinningPoStVerifyInfo) (bool, error) {
|
|
info.Randomness[31] &= 0x3f
|
|
_, span := trace.StartSpan(ctx, "VerifyWinningPoSt")
|
|
defer span.End()
|
|
|
|
return ffi.VerifyWinningPoSt(info)
|
|
}
|
|
|
|
func (proofVerifier) VerifyWindowPoSt(ctx context.Context, info proof5.WindowPoStVerifyInfo) (bool, error) {
|
|
info.Randomness[31] &= 0x3f
|
|
_, span := trace.StartSpan(ctx, "VerifyWindowPoSt")
|
|
defer span.End()
|
|
|
|
return ffi.VerifyWindowPoSt(info)
|
|
}
|
|
|
|
func (proofVerifier) GenerateWinningPoStSectorChallenge(ctx context.Context, proofType abi.RegisteredPoStProof, minerID abi.ActorID, randomness abi.PoStRandomness, eligibleSectorCount uint64) ([]uint64, error) {
|
|
randomness[31] &= 0x3f
|
|
return ffi.GenerateWinningPoStSectorChallenge(proofType, minerID, randomness, eligibleSectorCount)
|
|
}
|