package wrapper import ( "strconv" "github.com/nspcc-dev/neofs-node/pkg/morph/client/netmap" "github.com/pkg/errors" ) const ( maxObjectSizeConfig = "MaxObjectSize" basicIncomeRateConfig = "BasicIncomeRate" auditFeeConfig = "AuditFee" epochDurationConfig = "EpochDuration" containerFeeConfig = "ContainerFee" etIterationsConfig = "EigenTrustIterations" etAlphaConfig = "EigenTrustAlpha" irCandidateFeeConfig = "InnerRingCandidateFee" withdrawFeeConfig = "WithdrawFee" ) // MaxObjectSize receives max object size configuration // value through the Netmap contract call. func (w *Wrapper) MaxObjectSize() (uint64, error) { objectSize, err := w.readUInt64Config(maxObjectSizeConfig) if err != nil { return 0, errors.Wrapf(err, "(%T) could not get epoch number", w) } return objectSize, nil } // BasicIncomeRate returns basic income rate configuration value from network // config in netmap contract. func (w *Wrapper) BasicIncomeRate() (uint64, error) { rate, err := w.readUInt64Config(basicIncomeRateConfig) if err != nil { return 0, errors.Wrapf(err, "(%T) could not get basic income rate", w) } return rate, nil } // AuditFee returns audit fee configuration value from network // config in netmap contract. func (w *Wrapper) AuditFee() (uint64, error) { fee, err := w.readUInt64Config(auditFeeConfig) if err != nil { return 0, errors.Wrapf(err, "(%T) could not get audit fee", w) } return fee, nil } // EpochDuration returns number of sidechain blocks per one NeoFS epoch. func (w *Wrapper) EpochDuration() (uint64, error) { epochDuration, err := w.readUInt64Config(epochDurationConfig) if err != nil { return 0, errors.Wrapf(err, "(%T) could not get epoch duration", w) } return epochDuration, nil } // ContainerFee returns fee paid by container owner to each alphabet node // for container registration. func (w *Wrapper) ContainerFee() (uint64, error) { fee, err := w.readUInt64Config(containerFeeConfig) if err != nil { return 0, errors.Wrapf(err, "(%T) could not get container fee", w) } return fee, nil } // EigenTrustIterations returns global configuration value of iteration cycles // for EigenTrust algorithm per epoch. func (w *Wrapper) EigenTrustIterations() (uint64, error) { iterations, err := w.readUInt64Config(etIterationsConfig) if err != nil { return 0, errors.Wrapf(err, "(%T) could not get eigen trust iterations", w) } return iterations, nil } // EigenTrustAlpha returns global configuration value of alpha parameter. // It receives the alpha as a string and tries to convert it to float. func (w *Wrapper) EigenTrustAlpha() (float64, error) { strAlpha, err := w.readStringConfig(etAlphaConfig) if err != nil { return 0, errors.Wrapf(err, "(%T) could not get eigen trust alpha", w) } return strconv.ParseFloat(strAlpha, 64) } // InnerRingCandidateFee returns global configuration value of fee paid by // node to be in inner ring candidates list. func (w *Wrapper) InnerRingCandidateFee() (uint64, error) { fee, err := w.readUInt64Config(irCandidateFeeConfig) if err != nil { return 0, errors.Wrapf(err, "(%T) could not get inner ring candidate fee", w) } return fee, nil } // WithdrawFee returns global configuration value of fee paid by user to // withdraw assets from NeoFS contract. func (w *Wrapper) WithdrawFee() (uint64, error) { fee, err := w.readUInt64Config(withdrawFeeConfig) if err != nil { return 0, errors.Wrapf(err, "(%T) could not get withdraw fee", w) } return fee, nil } func (w *Wrapper) readUInt64Config(key string) (uint64, error) { args := netmap.ConfigArgs{} args.SetKey([]byte(key)) vals, err := w.client.Config(args, netmap.IntegerAssert) if err != nil { return 0, err } v := vals.Value() numeric, ok := v.(int64) if !ok { return 0, errors.Errorf("(%T) invalid value type %T", w, v) } return uint64(numeric), nil } func (w *Wrapper) readStringConfig(key string) (string, error) { args := netmap.ConfigArgs{} args.SetKey([]byte(key)) vals, err := w.client.Config(args, netmap.StringAssert) if err != nil { return "", err } v := vals.Value() str, ok := v.(string) if !ok { return "", errors.Errorf("(%T) invalid value type %T", w, v) } return str, nil }