Skip to content

I
interface-test
Commit c8fff73b authored by 董子豪's avatar 董子豪
Browse files
Options

test

parent 1dca9e59
Hide whitespace changes
Inline Side-by-side
Showing with 435 additions and 389 deletions
seal/seal_api.go
View file @ c8fff73b
package seal package seal
import( import(
"context" "context"
"io" "io"
"io/ioutil" "io/ioutil"
"os" "os"
"bytes" "bytes"
"math/rand" "math/rand"
saproof2 "github.com/filecoin-project/specs-actors/v2/actors/runtime/proof" saproof2 "github.com/filecoin-project/specs-actors/v2/actors/runtime/proof"
"golang.org/x/xerrors" "golang.org/x/xerrors"
proof5 "github.com/filecoin-project/specs-actors/v5/actors/runtime/proof" proof5 "github.com/filecoin-project/specs-actors/v5/actors/runtime/proof"
logging "github.com/ipfs/go-log/v2" logging "github.com/ipfs/go-log/v2"
"github.com/mitchellh/go-homedir" "github.com/mitchellh/go-homedir"
commcid "github.com/filecoin-project/go-fil-commcid" commcid "github.com/filecoin-project/go-fil-commcid"
"fil_integrate/extern/sector-storage/ffiwrapper" "fil_integrate/extern/sector-storage/ffiwrapper"
"fil_integrate/extern/sector-storage/ffiwrapper/basicfs" "fil_integrate/extern/sector-storage/ffiwrapper/basicfs"
"fil_integrate/extern/sector-storage/storiface" "fil_integrate/extern/sector-storage/storiface"
"github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/specs-storage/storage"
"github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/abi"
"github.com/filecoin-project/go-state-types/network" "github.com/filecoin-project/go-state-types/network"
"github.com/ipfs/go-cid" "github.com/ipfs/go-cid"
"github.com/minio/blake2b-simd" "github.com/minio/blake2b-simd"
"fil_integrate/chain/actors/builtin/miner" "fil_integrate/chain/actors/builtin/miner"
lapi "github.com/filecoin-project/lotus/api" lapi "github.com/filecoin-project/lotus/api"
) )
var log = logging.Logger("sealing") var log = logging.Logger("sealing")
//32字节，总共256位 //32字节，总共256位
//[has_pre][MetaLen1..MetaLen4][PieceLen1..PieceLen4] //[has_pre][MetaLen1..MetaLen4][PieceLen1..PieceLen4]
const TagLen int = 8 const TagLen int = 8
const NewestNetworkVersion = network.Version13 const NewestNetworkVersion = network.Version13
func AddPiece(sb *ffiwrapper.Sealer, ctx context.Context, sector storage.SectorRef, existingPieceSizes []abi.UnpaddedPieceSize, pieceSize abi.UnpaddedPieceSize, file storage.Data) (abi.PieceInfo, error) { func AddPiece(sb *ffiwrapper.Sealer, ctx context.Context, sector storage.SectorRef, existingPieceSizes []abi.UnpaddedPieceSize, pieceSize abi.UnpaddedPieceSize, file storage.Data) (abi.PieceInfo, error) {
return sb.AddPiece(ctx, sector, existingPieceSizes, pieceSize, file) return sb.AddPiece(ctx, sector, existingPieceSizes, pieceSize, file)
} }
// 没有测试 // 没有测试
// func EncodeDataToPieces(sb *ffiwrapper.Sealer, ctx context.Context, sector storage.SectorRef, sectorSize abi.SectorSize, file storage.Data) (abi.PieceInfo, error) { // func EncodeDataToPieces(sb *ffiwrapper.Sealer, ctx context.Context, sector storage.SectorRef, sectorSize abi.SectorSize, file storage.Data) (abi.PieceInfo, error) {
// var piecesID []byte // var piecesID []byte
// var FinalPiece abi.PieceInfo // var FinalPiece abi.PieceInfo
// var pieceNumber int32 = 1
// UnpaddedSectorSize := abi.PaddedPieceSize(sectorSize).Unpadded()
// buf := make([]byte, UnpaddedSectorSize) // UnpaddedSectorSize := abi.PaddedPieceSize(sectorSize).Unpadded()
// buf := make([]byte, UnpaddedSectorSize)
// DataLen := UnpaddedSectorSize-TagLen
// DataLen := UnpaddedSectorSize-TagLen
// for{
// copy(buf[:TagLen], 0) // for{
// var MetaLen int = 0 // copy(buf[:TagLen], 0)
// var rerr error // var MetaLen int = 0
// for rbuf := buf[TagLen:]; len(rbuf) > 0; { // var rerr error
// n, rerr := file.read(buf[TagLen:]) // for rbuf := buf[TagLen:]; len(rbuf) > 0; {
// n, rerr := file.read(buf[TagLen:])
// if rerr != nil && rerr != io.EOF{
// return nil, rerr // if rerr != nil && rerr != io.EOF{
// } // return nil, rerr
// rbuf = rbuf[n:] // }
// MetaLen += n; // rbuf = rbuf[n:]
// MetaLen += n
// if rerr == io.EOF{
// break; // if rerr == io.EOF{
// } // break
// } // }
// if rerr == io.EOF{ // }
// //encode first sector // if rerr == io.EOF{
// FinalPiece, err = EncodeData(buf, MetaLen, DataLen, piecesID) // //encode first sector
// if err != nil{ // pieceNumber, FinalPiece, err = EncodeData(buf, MetaLen, DataLen, piecesID, pieceNumber)
// return nil, err // if err != nil{
// } // return nil, err
// break // }
// } // break
// copy(buf[:4], []byte(MetaLen)) // }
// copy(buf[:4], []byte(MetaLen))
// piece, err := sb.AddPiece(ctx, sector, nil, UnpaddedSectorSize, bytes.NewReader(buf))
// if err != nil{ // piece, err := sb.AddPiece(ctx, sector, nil, UnpaddedSectorSize, bytes.NewReader(buf), pieceNumber)
// return nil, err // if err != nil{
// } // return nil, err
// piecesID = append(pieces, commcid.CIDToReplicaCommitmentV1(piece.PieceCID)...) // }
// } // piecesID = append(pieces, commcid.CIDToReplicaCommitmentV1(piece.PieceCID)...)
// return FinalPiece, nil // pieceNumber += 1
// } // }
// return pieceNumber, FinalPiece, nil
// func EncodeData(buf []byte, MetaLen int, DataLen int, piecesID []byte) (abi.PieceInfo, error) { // }
// //encode first sector
// remain := len(piecesID) // func EncodeData(buf []byte, MetaLen int, DataLen int, piecesID []byte, pieceNumber int32) (int32, abi.PieceInfo, error) {
// CommLen := min(remain, ((DataLen-MetaLen)/32) * 32) // //encode first sector
// rbuf := buf[MetaLen+TagLen:] // remain := len(piecesID)
// CommLen := min(remain, ((DataLen-MetaLen)/32) * 32)
// copy(buf[:4], []byte(MetaLen)) // rbuf := buf[MetaLen+TagLen:]
// copy(buf[4:8], []byte(CommLen))
// copy(rbuf, piecesID[:CommLen]) // copy(buf[:4], []byte(MetaLen))
// copy(rbuf[CommLen:], 0) // copy(buf[4:8], []byte(CommLen))
// copy(rbuf, piecesID[:CommLen])
// piecesID = piecesID[CommLen:] // copy(rbuf[CommLen:], 0)
// MetaLen = 0
// remain -= CommLen // piecesID = piecesID[CommLen:]
// rbuf = buf[TagLen+32:] // MetaLen = 0
// remain -= CommLen
// prePiece, err := sb.AddPiece(ctx, sector, nil, UnpaddedSectorSize, bytes.NewReader(buf)) // rbuf = buf[TagLen+32:]
// if err != nil{
// return nil, err // prePiece, err := sb.AddPiece(ctx, sector, nil, UnpaddedSectorSize, bytes.NewReader(buf), pieceNumber)
// } // pieceNumber += 1
// if err != nil{
// for ;remain > 0; { // return nil, err
// //encode next n sector // }
// CommLen := min(remain, ((DataLen-32)/32) * 32)
// for ;remain > 0; {
// copy(buf[:4], []byte(MetaLen | 0x80000000)) // //encode next n sector
// copy(buf[4:8], []byte(CommLen)) // CommLen := min(remain, ((DataLen-32)/32) * 32)
// copy(buf[8:40], commcid.CIDToReplicaCommitmentV1(prePiece.PieceCID)...)
// copy(rbuf, piecesID[:CommLen]) // copy(buf[:4], []byte(MetaLen | 0x80000000))
// copy(rbuf[CommLen:], 0) // copy(buf[4:8], []byte(CommLen))
// copy(buf[8:40], commcid.CIDToReplicaCommitmentV1(prePiece.PieceCID)...)
// piecesID = piecesID[CommLen:] // copy(rbuf, piecesID[:CommLen])
// MetaLen = 0 // copy(rbuf[CommLen:], 0)
// remain -= CommLen
// rbuf = buf[TagLen:] // piecesID = piecesID[CommLen:]
// MetaLen = 0
// prePiece, err = sb.AddPiece(ctx, sector, nil, UnpaddedSectorSize, bytes.NewReader(buf)) // remain -= CommLen
// if err != nil{ // rbuf = buf[TagLen:]
// return nil, err
// } // prePiece, err = sb.AddPiece(ctx, sector, nil, UnpaddedSectorSize, bytes.NewReader(buf), pieceNumber)
// } // pieceNumber += 1
// if err != nil{
// return prePiece, nil // return nil, err
// } // }
// }
// func DecodePieceToData(sb *ffiwrapper.Sealer, ctx context.Context, ) ([]abi.PieceInfo, error){
// return pieceNumber, prePiece, nil
// } // }
func CheckPieceAndDataRoot(sid storage.SectorRef, comm_d cid.Cid, pieces []abi.PieceInfo) (bool, error){ // func DecodePieceToData(sb *ffiwrapper.Sealer, ctx context.Context, out io.Writer, finalPiece abi.PieceInfo, pieceNum int32, sectorSize abi.SectorSize) ([]abi.PieceInfo, error){
UnsealedCID, err := ffiwrapper.GenerateUnsealedCID(sid.ProofType, pieces) // var piecesID []abi.PieceInfo
if err != nil{ // var commds []byte
return false, err
} // unpaddedSectorSize := abi.PaddedPieceSize(sectorSize).Unpadded()
// buf := make([]byte, unpaddedSectorSize)
return comm_d == UnsealedCID, nil // DataLen := unpaddedSectorSize-TagLen
}
// for ;pieceNum > 0; PieceNum-- {
func Sealed(sb *ffiwrapper.Sealer, ctx context.Context, sid storage.SectorRef, seed lapi.SealSeed, ticket abi.SealRandomness, pieces []abi.PieceInfo)(storage.SectorCids, storage.Proof, storage.Commit1Out, error){ // ok, err := sb.ReadPiece(ctx, sid, bytes.NewWriter(buf), 0, unpaddedSectorSize, pieceNum)
// var sealedSectors saproof2.SectorInfo // if err != nil {
// return nil
log.Infof("[%d] Running replication(1)...", sid.ID.Number) // }
// if !ok {
pc1out, err := sb.SealPreCommit1(ctx, sid, ticket, pieces) // return xerrors.Errorf("Read pieces error!")
if err != nil { // }
return storage.SectorCids{}, nil, nil, xerrors.Errorf("commit: %w", err)
} // MetaLen := buf[0:4] & 0x7fffffff
// HasPre := buf[0:4] >> 31
log.Infof("[%d] Running replication(2)...", sid.ID.Number) // CommLen := buf[4:8]
cids, err := sb.SealPreCommit2(ctx, sid, pc1out) // rbuf := buf[8:]
if err != nil {
return storage.SectorCids{}, nil, nil, xerrors.Errorf("commit: %w", err) // if HasPre {
} // prePiece := buf[8:40]
// CommLen -= 32
log.Infof("[%d] Generating PoRep for sector (1)", sid.ID.Number) // rbuf = rbuf[32:]
c1o, err := sb.SealCommit1(ctx, sid, ticket, seed.Value, pieces, cids) // commd, _ := commcid.DataCommitmentV1ToCID(prePiece)
if err != nil { // piecesID = append(piecesID, abi.PieceInfo{abi.PaddedPieceSize(sectorSize), commd})
return storage.SectorCids{}, nil, nil, err // }
} // data := rbuf[:MetaLen]
// commds = append(commds, rbuf[MetaLen:MetaLen+CommLen]...)
log.Infof("[%d] Generating PoRep for sector (2)", sid.ID.Number) // //**data顺序错了，需要
// n, werr := out.write(data[:])
var proof storage.Proof // if werr != nil {
proof, err = sb.SealCommit2(ctx, sid, c1o) // return nil, werr
if err != nil { // }
return storage.SectorCids{}, nil, nil, err // }
}
// for cbuf := commds; len(cbuf) > 0; {
return cids, proof, c1o, nil // commd, _ := cbuf.DataCommitmentV1ToCID(commds[32])
} // piecesID = append(piecesID, abi.PieceInfo{abi.PaddedPieceSize(sectorSize), commd})
// cbuf = cbuf[32:]
func GenProofForC2(sb *ffiwrapper.Sealer, ctx context.Context, sid storage.SectorRef, c1Out storage.Commit1Out) (storage.Proof, error) { // }
return sb.SealCommit2(ctx, sid, c1Out) // return piecesID, nil
} // }
func GenProofForWindowPost(sb *ffiwrapper.Sealer, ctx context.Context, minerID abi.ActorID, sectorInfo []proof5.SectorInfo, randomness abi.PoStRandomness) ([]proof5.PoStProof, []abi.SectorID, error) { func CheckPieceAndDataRoot(sid storage.SectorRef, comm_d cid.Cid, pieces []abi.PieceInfo) (bool, error){
return sb.GenerateWindowPoSt(ctx, minerID, sectorInfo, randomness) UnsealedCID, err := ffiwrapper.GenerateUnsealedCID(sid.ProofType, pieces)
} if err != nil{
return false, err
func UnsealedRange(sb *ffiwrapper.Sealer, ctx context.Context, sbfs *basicfs.Provider, sid storage.SectorRef, sectorSize abi.SectorSize, ticket abi.SealRandomness, commd cid.Cid, out io.Writer, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) error { }
log.Infof("[%d] Unsealing sector", sid.ID.Number)
{ return comm_d == UnsealedCID, nil
p, done, err := sbfs.AcquireSector(ctx, sid, storiface.FTUnsealed, storiface.FTNone, storiface.PathSealing) }
if err != nil {
return xerrors.Errorf("acquire unsealed sector for removing: %w", err) func Sealed(sb *ffiwrapper.Sealer, ctx context.Context, sid storage.SectorRef, seed lapi.SealSeed, ticket abi.SealRandomness, pieces []abi.PieceInfo)(storage.SectorCids, storage.Proof, storage.Commit1Out, error){
} // var sealedSectors saproof2.SectorInfo
done()
log.Infof("[%d] Running replication(1)...", sid.ID.Number)
if err := os.Remove(p.Unsealed); err != nil {
return xerrors.Errorf("removing unsealed sector: %w", err) pc1out, err := sb.SealPreCommit1(ctx, sid, ticket, pieces)
} if err != nil {
} return storage.SectorCids{}, nil, nil, xerrors.Errorf("commit: %w", err)
}
err := sb.UnsealPiece(ctx, sid, 0, abi.PaddedPieceSize(sectorSize).Unpadded(), ticket, commd)
if err != nil { log.Infof("[%d] Running replication(2)...", sid.ID.Number)
return err cids, err := sb.SealPreCommit2(ctx, sid, pc1out)
} if err != nil {
return storage.SectorCids{}, nil, nil, xerrors.Errorf("commit: %w", err)
ok, err := sb.ReadPiece(ctx, out, sid, offset, size) }
if err != nil{
return err log.Infof("[%d] Generating PoRep for sector (1)", sid.ID.Number)
} c1o, err := sb.SealCommit1(ctx, sid, ticket, seed.Value, pieces, cids)
if err != nil {
if !ok { return storage.SectorCids{}, nil, nil, err
return xerrors.Errorf("Read pieces error!") }
}
log.Infof("[%d] Generating PoRep for sector (2)", sid.ID.Number)
return nil
var proof storage.Proof
} proof, err = sb.SealCommit2(ctx, sid, c1o)
if err != nil {
func spt(ssize abi.SectorSize) abi.RegisteredSealProof { return storage.SectorCids{}, nil, nil, err
spt, err := miner.SealProofTypeFromSectorSize(ssize, NewestNetworkVersion) }
if err != nil {
panic(err) return cids, proof, c1o, nil
} }
return spt func GenProofForC2(sb *ffiwrapper.Sealer, ctx context.Context, sid storage.SectorRef, c1Out storage.Commit1Out) (storage.Proof, error) {
} return sb.SealCommit2(ctx, sid, c1Out)
}
func TestSealAndUnseal() error {
//********************need (sb,ctx,sid,sectorSize,file,seed,ticket,challenge)****************// func GenProofForWindowPost(sb *ffiwrapper.Sealer, ctx context.Context, minerID abi.ActorID, sectorInfo []proof5.SectorInfo, randomness abi.PoStRandomness) ([]proof5.PoStProof, []abi.SectorID, error) {
sdir, err := homedir.Expand("~/tmp") return sb.GenerateWindowPoSt(ctx, minerID, sectorInfo, randomness)
if err != nil { }
return err
} func UnsealedRange(sb *ffiwrapper.Sealer, ctx context.Context, sbfs *basicfs.Provider, sid storage.SectorRef, sectorSize abi.SectorSize, ticket abi.SealRandomness, commd cid.Cid, out io.Writer, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) error {
log.Infof("[%d] Unsealing sector", sid.ID.Number)
err = os.MkdirAll(sdir, 0775) //nolint:gosec {
if err != nil { p, done, err := sbfs.AcquireSector(ctx, sid, storiface.FTUnsealed, storiface.FTNone, storiface.PathSealing)
return xerrors.Errorf("creating sectorbuilder dir: %w", err) if err != nil {
} return xerrors.Errorf("acquire unsealed sector for removing: %w", err)
}
tsdir, err := ioutil.TempDir(sdir, "bench") done()
if err != nil {
return err if err := os.Remove(p.Unsealed); err != nil {
} return xerrors.Errorf("removing unsealed sector: %w", err)
// defer func() { }
// if err := os.RemoveAll(tsdir); err != nil { }
// log.Warn("remove all: ", err)
// } err := sb.UnsealPiece(ctx, sid, 0, abi.PaddedPieceSize(sectorSize).Unpadded(), ticket, commd)
// }() if err != nil {
return err
// TODO: pretty sure this isnt even needed? }
if err := os.MkdirAll(tsdir, 0775); err != nil {
return err ok, err := sb.ReadPiece(ctx, out, sid, offset, size)
} if err != nil{
sbfs := &basicfs.Provider{ return err
Root: tsdir, }
}
sb ,err := ffiwrapper.New(sbfs) if !ok {
if err != nil{ return xerrors.Errorf("Read pieces error!")
return err }
}
ctx := context.TODO() return nil
sectorSize := abi.SectorSize(8*1024*1024)
sid := storage.SectorRef{ }
ID: abi.SectorID{
Miner: 1000, func spt(ssize abi.SectorSize) abi.RegisteredSealProof {
Number: 0, spt, err := miner.SealProofTypeFromSectorSize(ssize, NewestNetworkVersion)
}, if err != nil {
ProofType: spt(sectorSize), panic(err)
} }
file := rand.New(rand.NewSource(1587))
seed := lapi.SealSeed{ return spt
Epoch: 101, }
Value: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 255},
} func TestSealAndUnseal() error {
trand := blake2b.Sum256([]byte("ticket-preimage")) //********************need (sb,ctx,sid,sectorSize,file,seed,ticket,challenge)****************//
ticket := abi.SealRandomness(trand[:]) sdir, err := homedir.Expand("~/tmp")
var challenge [32]byte if err != nil {
rand.Read(challenge[:]) return err
//ADD PIECES }
var existingPieceSizes []abi.UnpaddedPieceSize
var pieces []abi.PieceInfo err = os.MkdirAll(sdir, 0775) //nolint:gosec
var sealedSectors []saproof2.SectorInfo if err != nil {
return xerrors.Errorf("creating sectorbuilder dir: %w", err)
piece, err := AddPiece(sb, ctx, sid, existingPieceSizes, abi.PaddedPieceSize(sectorSize/2).Unpadded(), file) }
if err != nil {
return err tsdir, err := ioutil.TempDir(sdir, "bench")
} if err != nil {
return err
existingPieceSizes = append(existingPieceSizes, piece.Size.Unpadded()) }
pieces = append(pieces, piece) // defer func() {
// if err := os.RemoveAll(tsdir); err != nil {
piece, err = AddPiece(sb, ctx, sid, existingPieceSizes, abi.PaddedPieceSize(sectorSize/2).Unpadded(), file) // log.Warn("remove all: ", err)
if err != nil { // }
return err // }()
}
// TODO: pretty sure this isnt even needed?
existingPieceSizes = append(existingPieceSizes, piece.Size.Unpadded()) if err := os.MkdirAll(tsdir, 0775); err != nil {
pieces = append(pieces, piece) return err
}
//SEAL sbfs := &basicfs.Provider{
cids, proof1, c1o, err := Sealed(sb, ctx, sid, seed, ticket, pieces) Root: tsdir,
if err != nil { }
return err sb ,err := ffiwrapper.New(sbfs)
} if err != nil{
return err
sealedSectors = append(sealedSectors, saproof2.SectorInfo{ }
SealedCID: cids.Sealed, ctx := context.TODO()
SectorNumber: sid.ID.Number, sectorSize := abi.SectorSize(8*1024*1024)
SealProof: sid.ProofType, sid := storage.SectorRef{
}) ID: abi.SectorID{
Miner: 1000,
proof2, err := GenProofForC2(sb , ctx, sid, c1o) Number: 0,
if err != nil { },
return err ProofType: spt(sectorSize),
} }
file := rand.New(rand.NewSource(1587))
ok, err := CheckPieceAndDataRoot(sid, cids.Unsealed, pieces) seed := lapi.SealSeed{
if err != nil { Epoch: 101,
return err Value: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 255},
} }
trand := blake2b.Sum256([]byte("ticket-preimage"))
if !ok { ticket := abi.SealRandomness(trand[:])
return xerrors.Errorf("commd and pieces info don't match") var challenge [32]byte
} rand.Read(challenge[:])
//ADD PIECES
//verify proof var existingPieceSizes []abi.UnpaddedPieceSize
svi1 := saproof2.SealVerifyInfo{ var pieces []abi.PieceInfo
SectorID: sid.ID, var sealedSectors []saproof2.SectorInfo
SealedCID: cids.Sealed,
SealProof: sid.ProofType, piece, err := AddPiece(sb, ctx, sid, existingPieceSizes, abi.PaddedPieceSize(sectorSize/2).Unpadded(), file)
Proof: proof1, if err != nil {
DealIDs: nil, return err
Randomness: ticket, }
InteractiveRandomness: seed.Value,
UnsealedCID: cids.Unsealed, existingPieceSizes = append(existingPieceSizes, piece.Size.Unpadded())
} pieces = append(pieces, piece)
svi2 := saproof2.SealVerifyInfo{ piece, err = AddPiece(sb, ctx, sid, existingPieceSizes, abi.PaddedPieceSize(sectorSize/2).Unpadded(), file)
SectorID: sid.ID, if err != nil {
SealedCID: cids.Sealed, return err
SealProof: sid.ProofType, }
Proof: proof2,
DealIDs: nil, existingPieceSizes = append(existingPieceSizes, piece.Size.Unpadded())
Randomness: ticket, pieces = append(pieces, piece)
InteractiveRandomness: seed.Value,
UnsealedCID: cids.Unsealed, //SEAL
} cids, proof1, c1o, err := Sealed(sb, ctx, sid, seed, ticket, pieces)
if err != nil {
ok, err = ffiwrapper.ProofVerifier.VerifySeal(svi1) return err
if err != nil { }
return err
} sealedSectors = append(sealedSectors, saproof2.SectorInfo{
if !ok { SealedCID: cids.Sealed,
return xerrors.Errorf("porep proof for sector %d was invalid", sid.ID.Number) SectorNumber: sid.ID.Number,
} SealProof: sid.ProofType,
})
ok, err = ffiwrapper.ProofVerifier.VerifySeal(svi2)
if err != nil { proof2, err := GenProofForC2(sb , ctx, sid, c1o)
return err if err != nil {
} return err
if !ok { }
return xerrors.Errorf("porep proof for sector %d was invalid", sid.ID.Number)
} ok, err := CheckPieceAndDataRoot(sid, cids.Unsealed, pieces)
if err != nil {
proof, _, err := GenProofForWindowPost(sb, ctx, sid.ID.Miner, sealedSectors, challenge[:]) return err
}
wpvi := saproof2.WindowPoStVerifyInfo{
Randomness: challenge[:], if !ok {
Proofs: proof, return xerrors.Errorf("commd and pieces info don't match")
ChallengedSectors: sealedSectors, }
Prover: sid.ID.Miner,
} //verify proof
svi1 := saproof2.SealVerifyInfo{
ok, err = ffiwrapper.ProofVerifier.VerifyWindowPoSt(ctx, wpvi) SectorID: sid.ID,
if err != nil { SealedCID: cids.Sealed,
return err SealProof: sid.ProofType,
} Proof: proof1,
if !ok { DealIDs: nil,
log.Error("window post verification failed") Randomness: ticket,
} InteractiveRandomness: seed.Value,
UnsealedCID: cids.Unsealed,
return nil }
svi2 := saproof2.SealVerifyInfo{
SectorID: sid.ID,
SealedCID: cids.Sealed,
SealProof: sid.ProofType,
Proof: proof2,
DealIDs: nil,
Randomness: ticket,
InteractiveRandomness: seed.Value,
UnsealedCID: cids.Unsealed,
}
ok, err = ffiwrapper.ProofVerifier.VerifySeal(svi1)
if err != nil {
return err
}
if !ok {
return xerrors.Errorf("porep proof for sector %d was invalid", sid.ID.Number)
}
ok, err = ffiwrapper.ProofVerifier.VerifySeal(svi2)
if err != nil {
return err
}
if !ok {
return xerrors.Errorf("porep proof for sector %d was invalid", sid.ID.Number)
}
proof, _, err := GenProofForWindowPost(sb, ctx, sid.ID.Miner, sealedSectors, challenge[:])
wpvi := saproof2.WindowPoStVerifyInfo{
Randomness: challenge[:],
Proofs: proof,
ChallengedSectors: sealedSectors,
Prover: sid.ID.Miner,
}
ok, err = ffiwrapper.ProofVerifier.VerifyWindowPoSt(ctx, wpvi)
if err != nil {
return err
}
if !ok {
log.Error("window post verification failed")
}
return nil
} }
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment