acid-ant
/
frostfs-node
forked from TrueCloudLab/frostfs-node
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[#786] pkg/innerring: Use NNS to find contract script hashes missing in config 

Signed-off-by: Alex Vanin <alexey@nspcc.ru>
support/v0.27
Alex Vanin 2021-08-31 16:02:15 +03:00 committed by Alex Vanin
parent f43f389399
commit b6dfa6c118
2 changed files with 113 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

112
pkg/innerring/contracts.go 100644
View File

@ -0,0 +1,112 @@
package innerring
import (
"fmt"
"strings"
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/nspcc-dev/neofs-node/pkg/morph/client"
"github.com/spf13/viper"
)
type contracts struct {
neofs util.Uint160 // in mainnet
netmap util.Uint160 // in morph
balance util.Uint160 // in morph
container util.Uint160 // in morph
audit util.Uint160 // in morph
proxy util.Uint160 // in morph
processing util.Uint160 // in mainnet
reputation util.Uint160 // in morph
neofsID util.Uint160 // in morph
alphabet alphabetContracts // in morph
}
func parseContracts(cfg *viper.Viper, morph *client.Client, withoutMainNet, withoutMainNotary, withoutSideNotary bool) (*contracts, error) {
var (
result = new(contracts)
err error
)
if !withoutMainNet {
result.neofs, err = util.Uint160DecodeStringLE(cfg.GetString("contracts.neofs"))
if err != nil {
return nil, fmt.Errorf("can't get neofs script hash: %w", err)
}
if !withoutMainNotary {
result.processing, err = util.Uint160DecodeStringLE(cfg.GetString("contracts.processing"))
if err != nil {
return nil, fmt.Errorf("can't get processing script hash: %w", err)
}
}
}
if !withoutSideNotary {
result.proxy, err = parseContract(cfg, morph, "contracts.proxy", client.NNSProxyContractName)
if err != nil {
return nil, fmt.Errorf("can't get proxy script hash: %w", err)
}
}
targets := [...]struct {
cfgName string
nnsName string
dest *util.Uint160
}{
{"contracts.netmap", client.NNSNetmapContractName, &result.netmap},
{"contracts.balance", client.NNSBalanceContractName, &result.balance},
{"contracts.container", client.NNSContainerContractName, &result.container},
{"contracts.audit", client.NNSAuditContractName, &result.audit},
{"contracts.reputation", client.NNSReputationContractName, &result.reputation},
{"contracts.neofsid", client.NNSNeoFSIDContractName, &result.neofsID},
}
for _, t := range targets {
*t.dest, err = parseContract(cfg, morph, t.cfgName, t.nnsName)
if err != nil {
name := strings.TrimPrefix(t.cfgName, "contracts.")
return nil, fmt.Errorf("can't get %s script hash: %w", name, err)
}
}
result.alphabet, err = parseAlphabetContracts(cfg, morph)
if err != nil {
return nil, err
}
return result, nil
}
func parseAlphabetContracts(cfg *viper.Viper, morph *client.Client) (alphabetContracts, error) {
num := GlagoliticLetter(cfg.GetUint("contracts.alphabet.amount"))
alpha := newAlphabetContracts()
if num > lastLetterNum {
return nil, fmt.Errorf("amount of alphabet contracts overflows glagolitsa %d > %d", num, lastLetterNum)
}
for letter := az; letter < num; letter++ {
contractHash, err := parseContract(cfg, morph,
"contracts.alphabet."+letter.String(),
client.NNSAlphabetContractName(int(letter)),
)
if err != nil {
return nil, fmt.Errorf("invalid alphabet %s contract: %w", letter, err)
}
alpha.set(letter, contractHash)
}
return alpha, nil
}
func parseContract(cfg *viper.Viper, morph *client.Client, cfgName, nnsName string) (res util.Uint160, err error) {
contractStr := cfg.GetString(cfgName)
if len(contractStr) == 0 {
return morph.NNSContractAddress(nnsName)
}
return util.Uint160DecodeStringLE(contractStr)
}

109
pkg/innerring/innerring.go
View File

@ -120,20 +120,6 @@ type (
runners []func(chan<- error)
}
contracts struct {
neofs util.Uint160 // in mainnet
netmap util.Uint160 // in morph
balance util.Uint160 // in morph
container util.Uint160 // in morph
audit util.Uint160 // in morph
proxy util.Uint160 // in morph
processing util.Uint160 // in mainnet
reputation util.Uint160 // in morph
neofsID util.Uint160 // in morph
alphabet alphabetContracts // in morph
}
chainParams struct {
log *zap.Logger
cfg *viper.Viper
@ -418,6 +404,7 @@ func New(ctx context.Context, log *zap.Logger, cfg *viper.Viper) (*Server, error
// get all script hashes of contracts
server.contracts, err = parseContracts(
cfg,
server.morphClient,
server.withoutMainNet,
server.mainNotaryConfig.disabled,
server.sideNotaryConfig.disabled,
@ -931,78 +918,6 @@ func createClient(ctx context.Context, p *chainParams) (*client.Client, error) {
)
}
func parseContracts(cfg *viper.Viper, withoutMainNet, withoutMainNotary, withoutSideNotary bool) (*contracts, error) {
var (
result = new(contracts)
err error
)
if !withoutMainNet {
result.neofs, err = util.Uint160DecodeStringLE(cfg.GetString("contracts.neofs"))
if err != nil {
return nil, fmt.Errorf("ir: can't read neofs script-hash: %w", err)
}
if !withoutMainNotary {
result.processing, err = util.Uint160DecodeStringLE(cfg.GetString("contracts.processing"))
if err != nil {
return nil, fmt.Errorf("ir: can't read processing script-hash: %w", err)
}
}
}
if !withoutSideNotary {
result.proxy, err = util.Uint160DecodeStringLE(cfg.GetString("contracts.proxy"))
if err != nil {
return nil, fmt.Errorf("ir: can't read proxy script-hash: %w", err)
}
}
netmapContractStr := cfg.GetString("contracts.netmap")
balanceContractStr := cfg.GetString("contracts.balance")
containerContractStr := cfg.GetString("contracts.container")
auditContractStr := cfg.GetString("contracts.audit")
reputationContractStr := cfg.GetString("contracts.reputation")
neofsIDContractStr := cfg.GetString("contracts.neofsid")
result.netmap, err = util.Uint160DecodeStringLE(netmapContractStr)
if err != nil {
return nil, fmt.Errorf("ir: can't read netmap script-hash: %w", err)
}
result.balance, err = util.Uint160DecodeStringLE(balanceContractStr)
if err != nil {
return nil, fmt.Errorf("ir: can't read balance script-hash: %w", err)
}
result.container, err = util.Uint160DecodeStringLE(containerContractStr)
if err != nil {
return nil, fmt.Errorf("ir: can't read container script-hash: %w", err)
}
result.audit, err = util.Uint160DecodeStringLE(auditContractStr)
if err != nil {
return nil, fmt.Errorf("ir: can't read audit script-hash: %w", err)
}
result.reputation, err = util.Uint160DecodeStringLE(reputationContractStr)
if err != nil {
return nil, fmt.Errorf("ir: can't read reputation script-hash: %w", err)
}
result.neofsID, err = util.Uint160DecodeStringLE(neofsIDContractStr)
if err != nil {
return nil, fmt.Errorf("ir: can't read NeoFS ID script-hash: %w", err)
}
result.alphabet, err = parseAlphabetContracts(cfg)
if err != nil {
return nil, err
}
return result, nil
}
func parsePredefinedValidators(cfg *viper.Viper) (keys.PublicKeys, error) {
publicKeyStrings := cfg.GetStringSlice("morph.validators")
@ -1026,28 +941,6 @@ func ParsePublicKeysFromStrings(pubKeys []string) (keys.PublicKeys, error) {
return publicKeys, nil
}
func parseAlphabetContracts(cfg *viper.Viper) (alphabetContracts, error) {
num := GlagoliticLetter(cfg.GetUint("contracts.alphabet.amount"))
alpha := newAlphabetContracts()
if num > lastLetterNum {
return nil, fmt.Errorf("amount of alphabet contracts overflows glagolitsa %d > %d", num, lastLetterNum)
}
for letter := az; letter < num; letter++ {
contractStr := cfg.GetString("contracts.alphabet." + letter.String())
contractHash, err := util.Uint160DecodeStringLE(contractStr)
if err != nil {
return nil, fmt.Errorf("invalid alphabet %s contract: %s: %w", letter.String(), contractStr, err)
}
alpha.set(letter, contractHash)
}
return alpha, nil
}
func (s *Server) initConfigFromBlockchain() error {
// get current epoch
epoch, err := s.netmapClient.Epoch()