package internal import ( "context" "crypto/ecdsa" coreclient "github.com/nspcc-dev/neofs-node/pkg/core/client" "github.com/nspcc-dev/neofs-sdk-go/client" apistatus "github.com/nspcc-dev/neofs-sdk-go/client/status" "github.com/nspcc-dev/neofs-sdk-go/reputation" ) type commonPrm struct { cli coreclient.Client ctx context.Context epoch uint64 opts []client.CallOption } // SetClient sets base client for NeoFS API communication. // // Required parameter. func (x *commonPrm) SetClient(cli coreclient.Client) { x.cli = cli } // SetContext sets context.Context for network communication. // // Required parameter. func (x *commonPrm) SetContext(ctx context.Context) { x.ctx = ctx } // SetPrivateKey sets private key to sign the request(s). // // Required parameter. func (x *commonPrm) SetPrivateKey(key *ecdsa.PrivateKey) { x.opts = append(x.opts, client.WithKey(key)) } // AnnounceLocalPrm groups parameters of AnnounceLocal operation. type AnnounceLocalPrm struct { commonPrm cliPrm client.AnnounceLocalTrustPrm } // SetEpoch sets epoch in which the trust was assessed. func (x *AnnounceLocalPrm) SetEpoch(epoch uint64) { x.cliPrm.SetEpoch(epoch) } // SetTrusts sets list of local trust values. func (x *AnnounceLocalPrm) SetTrusts(ts []*reputation.Trust) { x.cliPrm.SetTrusts(ts) } // AnnounceLocalRes groups resulting values of AnnounceLocal operation. type AnnounceLocalRes struct{} // AnnounceLocal sends estimations of local trust to the remote node. // // Client, context and key must be set. // // Returns any error prevented the operation from completing correctly in error return. func AnnounceLocal(prm AnnounceLocalPrm) (res AnnounceLocalRes, err error) { var cliRes *client.AnnounceLocalTrustRes cliRes, err = prm.cli.AnnounceLocalTrust(prm.ctx, prm.cliPrm, prm.opts...) if err == nil { // pull out an error from status err = apistatus.ErrFromStatus(cliRes.Status()) } return } // AnnounceIntermediatePrm groups parameters of AnnounceIntermediate operation. type AnnounceIntermediatePrm struct { commonPrm cliPrm client.AnnounceIntermediateTrustPrm } // SetEpoch sets number of the epoch when the trust calculation's iteration was executed. func (x *AnnounceIntermediatePrm) SetEpoch(epoch uint64) { x.cliPrm.SetEpoch(epoch) } // SetIteration sets number of the iteration of the trust calculation algorithm. func (x *AnnounceIntermediatePrm) SetIteration(iter uint32) { x.cliPrm.SetIteration(iter) } // SetTrust sets current global trust value computed at the iteration. func (x *AnnounceIntermediatePrm) SetTrust(t *reputation.PeerToPeerTrust) { x.cliPrm.SetTrust(t) } // AnnounceIntermediateRes groups resulting values of AnnounceIntermediate operation. type AnnounceIntermediateRes struct{} // AnnounceIntermediate sends global trust value calculated at the specified iteration // and epoch to to the remote node. // // Client, context and key must be set. // // Returns any error prevented the operation from completing correctly in error return. func AnnounceIntermediate(prm AnnounceIntermediatePrm) (res AnnounceIntermediateRes, err error) { var cliRes *client.AnnounceIntermediateTrustRes cliRes, err = prm.cli.AnnounceIntermediateTrust(prm.ctx, prm.cliPrm, prm.opts...) if err == nil { // pull out an error from status err = apistatus.ErrFromStatus(cliRes.Status()) } return }