package main import ( "bufio" "context" "errors" proof7 "github.com/filecoin-project/specs-actors/v7/actors/runtime/proof" "github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper" proof2 "github.com/filecoin-project/specs-actors/v2/actors/runtime/proof" "github.com/ipfs/go-datastore" "github.com/minio/blake2b-simd" cbg "github.com/whyrusleeping/cbor-gen" ) type cachingVerifier struct { ds datastore.Datastore backend ffiwrapper.Verifier } const bufsize = 128 func (cv cachingVerifier) withCache(execute func() (bool, error), param cbg.CBORMarshaler) (bool, error) { hasher := blake2b.New256() wr := bufio.NewWriterSize(hasher, bufsize) err := param.MarshalCBOR(wr) if err != nil { log.Errorf("could not marshal call info: %+v", err) return execute() } err = wr.Flush() if err != nil { log.Errorf("could not flush: %+v", err) return execute() } hash := hasher.Sum(nil) key := datastore.NewKey(string(hash)) fromDs, err := cv.ds.Get(context.Background(), key) if err == nil { switch fromDs[0] { case 's': return true, nil case 'f': return false, nil case 'e': return false, errors.New(string(fromDs[1:])) default: log.Errorf("bad cached result in cache %s(%x)", fromDs[0], fromDs[0]) return execute() } } else if errors.Is(err, datastore.ErrNotFound) { // recalc ok, err := execute() var save []byte if err != nil { if ok { log.Errorf("success with an error: %+v", err) } else { save = append([]byte{'e'}, []byte(err.Error())...) } } else if ok { save = []byte{'s'} } else { save = []byte{'f'} } if len(save) != 0 { errSave := cv.ds.Put(context.Background(), key, save) if errSave != nil { log.Errorf("error saving result: %+v", errSave) } } return ok, err } else { log.Errorf("could not get data from cache: %+v", err) return execute() } } func (cv *cachingVerifier) VerifySeal(svi proof2.SealVerifyInfo) (bool, error) { return cv.withCache(func() (bool, error) { return cv.backend.VerifySeal(svi) }, &svi) } func (cv *cachingVerifier) VerifyWinningPoSt(ctx context.Context, info proof7.WinningPoStVerifyInfo) (bool, error) { return cv.backend.VerifyWinningPoSt(ctx, info) } func (cv *cachingVerifier) VerifyWindowPoSt(ctx context.Context, info proof2.WindowPoStVerifyInfo) (bool, error) { return cv.withCache(func() (bool, error) { return cv.backend.VerifyWindowPoSt(ctx, info) }, &info) } func (cv *cachingVerifier) GenerateWinningPoStSectorChallenge(ctx context.Context, proofType abi.RegisteredPoStProof, a abi.ActorID, rnd abi.PoStRandomness, u uint64) ([]uint64, error) { return cv.backend.GenerateWinningPoStSectorChallenge(ctx, proofType, a, rnd, u) } func (cv cachingVerifier) VerifyAggregateSeals(aggregate proof7.AggregateSealVerifyProofAndInfos) (bool, error) { return cv.backend.VerifyAggregateSeals(aggregate) } func (cv cachingVerifier) VerifyReplicaUpdate(update proof7.ReplicaUpdateInfo) (bool, error) { return cv.backend.VerifyReplicaUpdate(update) } var _ ffiwrapper.Verifier = (*cachingVerifier)(nil)