package morph import ( "encoding/hex" "errors" "fmt" "math" "github.com/nspcc-dev/neo-go/cli/flags" "github.com/nspcc-dev/neo-go/cli/input" "github.com/nspcc-dev/neo-go/pkg/crypto/keys" "github.com/nspcc-dev/neo-go/pkg/util" "github.com/nspcc-dev/neo-go/pkg/wallet" "github.com/nspcc-dev/neofs-node/cmd/neofs-adm/internal/modules/morph/internal" "github.com/nspcc-dev/neofs-node/pkg/morph/client" morphsubnet "github.com/nspcc-dev/neofs-node/pkg/morph/client/subnet" "github.com/nspcc-dev/neofs-node/pkg/util/rand" "github.com/nspcc-dev/neofs-sdk-go/owner" "github.com/nspcc-dev/neofs-sdk-go/subnet" subnetid "github.com/nspcc-dev/neofs-sdk-go/subnet/id" "github.com/spf13/cobra" "github.com/spf13/viper" ) // cmdSubnet flags. const ( // Neo RPC endpoint flagSubnetEndpoint = endpointFlag // filepath to wallet flagSubnetWallet = "wallet" // address in the wallet, optional flagSubnetAddress = "address" ) func viperBindFlags(cmd *cobra.Command, flags ...string) { for i := range flags { _ = viper.BindPFlag(flags[i], cmd.Flags().Lookup(flags[i])) } } // subnet command section. var cmdSubnet = &cobra.Command{ Use: "subnet", Short: "NeoFS subnet management.", PreRun: func(cmd *cobra.Command, _ []string) { viperBindFlags(cmd, flagSubnetEndpoint, flagSubnetWallet, flagSubnetAddress, ) }, } // shared flags of cmdSubnet sub-commands. const ( // subnet identifier flagSubnet = "subnet" // subnet client group ID flagSubnetGroup = "group" ) // reads wallet from the filepath configured in flagSubnetWallet flag, // looks for address specified in flagSubnetAddress flag (uses default // address if flag is empty) and decrypts private key. func readSubnetKey(key *keys.PrivateKey) error { // read wallet from file walletPath := viper.GetString(flagSubnetWallet) if walletPath == "" { return errors.New("missing path to wallet") } w, err := wallet.NewWalletFromFile(walletPath) if err != nil { return fmt.Errorf("read wallet from file: %w", err) } // read account from the wallet var ( addr util.Uint160 addrStr = viper.GetString(flagSubnetAddress) ) if addrStr == "" { addr = w.GetChangeAddress() } else { addr, err = flags.ParseAddress(addrStr) if err != nil { return fmt.Errorf("read wallet address: %w", err) } } acc := w.GetAccount(addr) if acc == nil { return fmt.Errorf("address %s not found in %s", addrStr, walletPath) } // read password pass, err := input.ReadPassword("Enter password > ") if err != nil { return fmt.Errorf("read password: %w", err) } // decrypt with just read password err = acc.Decrypt(pass, keys.NEP2ScryptParams()) if err != nil { return fmt.Errorf("decrypt wallet: %w", err) } *key = *acc.PrivateKey() return nil } // calls initSubnetClientCheckNotary with unset checkNotary. func initSubnetClient(c *morphsubnet.Client, key *keys.PrivateKey) error { return initSubnetClientCheckNotary(c, key, false) } const ( // enable notary flagSubnetNotary = "notary" ) // initializes morph subnet client with the specified private key. // // Parameters are read from: // * contract address: flagSubnetContract; // * endpoint: flagSubnetEndpoint. // // If checkNotary is set, notary mode is read from flagSubnetNotary. func initSubnetClientCheckNotary(c *morphsubnet.Client, key *keys.PrivateKey, checkNotary bool) error { // read endpoint endpoint := viper.GetString(flagSubnetEndpoint) if endpoint == "" { return errors.New("missing endpoint") } // create base morph client cMorph, err := client.New(key, endpoint) if err != nil { return err } // read contract address contractAddr, err := cMorph.NNSContractAddress(client.NNSSubnetworkContractName) if err != nil { return fmt.Errorf("read subnet contract address in NNS: %w", err) } // calc client mode cMode := morphsubnet.NonNotary if checkNotary && viper.GetBool(flagSubnetNotary) { err = cMorph.EnableNotarySupport() if err != nil { return fmt.Errorf("enable notary support: %w", err) } cMode = morphsubnet.NotaryNonAlphabet } // init subnet morph client var prmInit morphsubnet.InitPrm prmInit.SetBaseClient(cMorph) prmInit.SetContractAddress(contractAddr) prmInit.SetMode(cMode) if err := c.Init(prmInit); err != nil { return fmt.Errorf("init call: %w", err) } return nil } // create subnet command. var cmdSubnetCreate = &cobra.Command{ Use: "create", Short: "Create NeoFS subnet.", PreRun: func(cmd *cobra.Command, _ []string) { viperBindFlags(cmd, flagSubnetNotary, ) }, RunE: func(cmd *cobra.Command, _ []string) error { // read private key var key keys.PrivateKey err := readSubnetKey(&key) if err != nil { return fmt.Errorf("read private key: %w", err) } // calculate wallet address from key n3Wallet, err := owner.NEO3WalletFromPublicKey(&key.PrivateKey.PublicKey) if err != nil { return fmt.Errorf("wallet from key: %w", err) } // generate subnet ID and marshal it var ( id subnetid.ID num uint32 ) for { num = uint32(rand.Uint64(rand.New(), math.MaxUint32)) id.SetNumber(num) if !subnetid.IsZero(id) { break } } binID, err := id.Marshal() if err != nil { return fmt.Errorf("marshal subnet ID: %w", err) } // declare creator ID and encode it creator := *owner.NewIDFromNeo3Wallet(n3Wallet) // fill subnet info and encode it var info subnet.Info info.SetID(id) info.SetOwner(creator) binInfo, err := info.Marshal() if err != nil { return fmt.Errorf("marshal subnet info: %w", err) } // initialize morph subnet client var cSubnet morphsubnet.Client err = initSubnetClientCheckNotary(&cSubnet, &key, true) if err != nil { return fmt.Errorf("init subnet client: %w", err) } // prepare call parameters and create subnet var prm morphsubnet.PutPrm prm.SetID(binID) prm.SetOwner(key.PublicKey().Bytes()) prm.SetInfo(binInfo) _, err = cSubnet.Put(prm) if err != nil { return fmt.Errorf("morph call: %w", err) } cmd.Printf("Create subnet request sent successfully. ID: %s.\n", &id) return nil }, } // cmdSubnetRemove flags. const ( // subnet ID to be removed flagSubnetRemoveID = flagSubnet ) // errZeroSubnet is returned on attempts to work with zero subnet which is virtual. var errZeroSubnet = errors.New("zero subnet") // remove subnet command. var cmdSubnetRemove = &cobra.Command{ Use: "remove", Short: "Remove NeoFS subnet.", PreRun: func(cmd *cobra.Command, _ []string) { viperBindFlags(cmd, flagSubnetRemoveID, ) }, RunE: func(cmd *cobra.Command, _ []string) error { // read private key var key keys.PrivateKey err := readSubnetKey(&key) if err != nil { return fmt.Errorf("read private key: %w", err) } // read ID and encode it var id subnetid.ID err = id.UnmarshalText([]byte(viper.GetString(flagSubnetRemoveID))) if err != nil { return fmt.Errorf("decode ID text: %w", err) } if subnetid.IsZero(id) { return errZeroSubnet } binID, err := id.Marshal() if err != nil { return fmt.Errorf("marshal subnet ID: %w", err) } // initialize morph subnet client var cSubnet morphsubnet.Client // use random key to fetch the data // we could use raw neo-go client to perform testInvoke // without keys, as it is done in other commands key, err := keys.NewPrivateKey() if err != nil { return fmt.Errorf("init subnet client: %w", err) } err = initSubnetClient(&cSubnet, key) if err != nil { return fmt.Errorf("init subnet client: %w", err) } // prepare call parameters and remove subnet var prm morphsubnet.DeletePrm prm.SetID(binID) _, err = cSubnet.Delete(prm) if err != nil { return fmt.Errorf("morph call: %w", err) } cmd.Println("Remove subnet request sent successfully.") return nil }, } // cmdSubnetGet flags. const ( // subnet ID to be read flagSubnetGetID = flagSubnet ) // get subnet command. var cmdSubnetGet = &cobra.Command{ Use: "get", Short: "Read information about the NeoFS subnet.", PreRun: func(cmd *cobra.Command, _ []string) { viperBindFlags(cmd, flagSubnetGetID, ) }, RunE: func(cmd *cobra.Command, _ []string) error { // read ID and encode it var id subnetid.ID err := id.UnmarshalText([]byte(viper.GetString(flagSubnetGetID))) if err != nil { return fmt.Errorf("decode ID text: %w", err) } if subnetid.IsZero(id) { return errZeroSubnet } binID, err := id.Marshal() if err != nil { return fmt.Errorf("marshal subnet ID: %w", err) } // initialize morph subnet client var cSubnet morphsubnet.Client err = initSubnetClient(&cSubnet, &key) if err != nil { return fmt.Errorf("init subnet client: %w", err) } // prepare call parameters and read subnet var prm morphsubnet.GetPrm prm.SetID(binID) res, err := cSubnet.Get(prm) if err != nil { return fmt.Errorf("morph call: %w", err) } // decode info var info subnet.Info if err = info.Unmarshal(res.Info()); err != nil { return fmt.Errorf("decode subnet info: %w", err) } // print information var ownerID owner.ID info.ReadOwner(&ownerID) cmd.Printf("Owner: %s\n", &ownerID) return nil }, } // cmdSubnetAdmin subnet flags. const ( // subnet ID to be managed flagSubnetAdminSubnet = flagSubnet // admin public key flagSubnetAdminID = "admin" // manage client admins instead of node ones flagSubnetAdminClient = "client" ) // command to manage subnet admins. var cmdSubnetAdmin = &cobra.Command{ Use: "admin", Short: "Manage administrators of the NeoFS subnet.", PreRun: func(cmd *cobra.Command, args []string) { viperBindFlags(cmd, flagSubnetAdminSubnet, flagSubnetAdminID, ) }, } // cmdSubnetAdminAdd flags. const ( // client group ID flagSubnetAdminAddGroup = flagSubnetGroup ) // common executor cmdSubnetAdminAdd and cmdSubnetAdminRemove commands. func manageSubnetAdmins(cmd *cobra.Command, rm bool) error { // read private key var key keys.PrivateKey err := readSubnetKey(&key) if err != nil { return fmt.Errorf("read private key: %w", err) } // read ID and encode it var id subnetid.ID err = id.UnmarshalText([]byte(viper.GetString(flagSubnetAdminSubnet))) if err != nil { return fmt.Errorf("decode ID text: %w", err) } if subnetid.IsZero(id) { return errZeroSubnet } binID, err := id.Marshal() if err != nil { return fmt.Errorf("marshal subnet ID: %w", err) } // read admin key and decode it binAdminKey, err := hex.DecodeString(viper.GetString(flagSubnetAdminID)) if err != nil { return fmt.Errorf("decode admin key text: %w", err) } var pubkey keys.PublicKey if err = pubkey.DecodeBytes(binAdminKey); err != nil { return fmt.Errorf("admin key format: %w", err) } // prepare call parameters var prm morphsubnet.ManageAdminsPrm if viper.GetBool(flagSubnetAdminClient) { // read group ID and encode it var groupID internal.SubnetClientGroupID err = groupID.UnmarshalText([]byte(viper.GetString(flagSubnetAdminAddGroup))) if err != nil { return fmt.Errorf("decode group ID text: %w", err) } binGroupID, err := groupID.Marshal() if err != nil { return fmt.Errorf("marshal group ID: %w", err) } prm.SetClient() prm.SetGroup(binGroupID) } prm.SetSubnet(binID) prm.SetAdmin(binAdminKey) if rm { prm.SetRemove() } // initialize morph subnet client var cSubnet morphsubnet.Client err = initSubnetClient(&cSubnet, &key) if err != nil { return fmt.Errorf("init subnet client: %w", err) } _, err = cSubnet.ManageAdmins(prm) if err != nil { return fmt.Errorf("morph call: %w", err) } var op string if rm { op = "Remove" } else { op = "Add" } cmd.Printf("%s admin request sent successfully.\n", op) return nil } // command to add subnet admin. var cmdSubnetAdminAdd = &cobra.Command{ Use: "add", Short: "Add admin to the NeoFS subnet.", PreRun: func(cmd *cobra.Command, _ []string) { viperBindFlags(cmd, flagSubnetAdminAddGroup, flagSubnetAdminClient, ) }, RunE: func(cmd *cobra.Command, _ []string) error { return manageSubnetAdmins(cmd, false) }, } // command to remove subnet admin. var cmdSubnetAdminRemove = &cobra.Command{ Use: "remove", Short: "Remove admin of the NeoFS subnet.", PreRun: func(cmd *cobra.Command, _ []string) { viperBindFlags(cmd, flagSubnetAdminClient, ) }, RunE: func(cmd *cobra.Command, _ []string) error { return manageSubnetAdmins(cmd, true) }, } // cmdSubnetClient flags. const ( // ID of the subnet to be managed flagSubnetClientSubnet = flagSubnet // client's NeoFS ID flagSubnetClientID = flagSubnetAdminClient // ID of the subnet client group flagSubnetClientGroup = flagSubnetGroup ) // command to manage subnet clients. var cmdSubnetClient = &cobra.Command{ Use: "client", Short: "Manage clients of the NeoFS subnet.", PreRun: func(cmd *cobra.Command, _ []string) { viperBindFlags(cmd, flagSubnetClientSubnet, flagSubnetClientID, flagSubnetClientGroup, ) }, } // common executor cmdSubnetClientAdd and cmdSubnetClientRemove commands. func manageSubnetClients(cmd *cobra.Command, rm bool) error { // read private key var key keys.PrivateKey err := readSubnetKey(&key) if err != nil { return fmt.Errorf("read private key: %w", err) } // read ID and encode it var id subnetid.ID err = id.UnmarshalText([]byte(viper.GetString(flagSubnetClientSubnet))) if err != nil { return fmt.Errorf("decode ID text: %w", err) } if subnetid.IsZero(id) { return errZeroSubnet } binID, err := id.Marshal() if err != nil { return fmt.Errorf("marshal subnet ID: %w", err) } // read client ID and encode it var clientID owner.ID err = clientID.Parse(viper.GetString(flagSubnetClientID)) if err != nil { return fmt.Errorf("decode client ID text: %w", err) } binClientID, err := clientID.Marshal() if err != nil { return fmt.Errorf("marshal client ID: %w", err) } // read group ID and encode it var groupID internal.SubnetClientGroupID err = groupID.UnmarshalText([]byte(viper.GetString(flagSubnetAdminAddGroup))) if err != nil { return fmt.Errorf("decode group ID text: %w", err) } binGroupID, err := groupID.Marshal() if err != nil { return fmt.Errorf("marshal group ID: %w", err) } var prm morphsubnet.ManageClientsPrm prm.SetGroup(binGroupID) prm.SetSubnet(binID) prm.SetClient(binClientID) if rm { prm.SetRemove() } // initialize morph subnet client var cSubnet morphsubnet.Client err = initSubnetClient(&cSubnet, &key) if err != nil { return fmt.Errorf("init subnet client: %w", err) } _, err = cSubnet.ManageClients(prm) if err != nil { return fmt.Errorf("morph call: %w", err) } var op string if rm { op = "Remove" } else { op = "Add" } cmd.Printf("%s client request sent successfully.\n", op) return nil } // command to add subnet client. var cmdSubnetClientAdd = &cobra.Command{ Use: "add", Short: "Add client to the NeoFS subnet.", RunE: func(cmd *cobra.Command, _ []string) error { return manageSubnetClients(cmd, false) }, } // command to remove subnet client. var cmdSubnetClientRemove = &cobra.Command{ Use: "remove", Short: "Remove client of the NeoFS subnet.", RunE: func(cmd *cobra.Command, _ []string) error { return manageSubnetClients(cmd, true) }, } // cmdSubnetNode flags. const ( // node ID flagSubnetNode = "node" // ID of the subnet to be managed flagSubnetNodeSubnet = flagSubnet ) // common executor cmdSubnetNodeAdd and cmdSubnetNodeRemove commands. func manageSubnetNodes(cmd *cobra.Command, rm bool) error { // read private key var key keys.PrivateKey err := readSubnetKey(&key) if err != nil { return fmt.Errorf("read private key: %w", err) } // read ID and encode it var id subnetid.ID err = id.UnmarshalText([]byte(viper.GetString(flagSubnetNodeSubnet))) if err != nil { return fmt.Errorf("decode ID text: %w", err) } if subnetid.IsZero(id) { return errZeroSubnet } binID, err := id.Marshal() if err != nil { return fmt.Errorf("marshal subnet ID: %w", err) } // read node ID and encode it binNodeID, err := hex.DecodeString(viper.GetString(flagSubnetNode)) if err != nil { return fmt.Errorf("decode node ID text: %w", err) } var pubkey keys.PublicKey if err = pubkey.DecodeBytes(binNodeID); err != nil { return fmt.Errorf("node ID format: %w", err) } var prm morphsubnet.ManageNodesPrm prm.SetSubnet(binID) prm.SetNode(binNodeID) if rm { prm.SetRemove() } // initialize morph subnet client var cSubnet morphsubnet.Client err = initSubnetClient(&cSubnet, &key) if err != nil { return fmt.Errorf("init subnet client: %w", err) } _, err = cSubnet.ManageNodes(prm) if err != nil { return fmt.Errorf("morph call: %w", err) } var op string if rm { op = "Remove" } else { op = "Add" } cmd.Printf("%s node request sent successfully.\n", op) return nil } // command to manage subnet nodes. var cmdSubnetNode = &cobra.Command{ Use: "node", Short: "Manage nodes of the NeoFS subnet.", PreRun: func(cmd *cobra.Command, _ []string) { viperBindFlags(cmd, flagSubnetNode, flagSubnetNodeSubnet, ) }, } // command to add subnet node. var cmdSubnetNodeAdd = &cobra.Command{ Use: "add", Short: "Add node to the NeoFS subnet.", RunE: func(cmd *cobra.Command, _ []string) error { return manageSubnetNodes(cmd, false) }, } // command to remove subnet node. var cmdSubnetNodeRemove = &cobra.Command{ Use: "remove", Short: "Remove node from the NeoFS subnet.", RunE: func(cmd *cobra.Command, _ []string) error { return manageSubnetNodes(cmd, true) }, } // returns function which calls PreRun on parent if it exists. func inheritPreRun(preRun func(*cobra.Command, []string)) func(*cobra.Command, []string) { return func(cmd *cobra.Command, args []string) { par := cmd.Parent() if par != nil && par.PreRun != nil { par.PreRun(par, args) } if preRun != nil { preRun(cmd, args) } } } // inherits PreRun function of parent command in all sub-commands and // adds them to the parent. func addCommandInheritPreRun(par *cobra.Command, subs ...*cobra.Command) { for _, sub := range subs { sub.PreRun = inheritPreRun(sub.PreRun) } par.AddCommand(subs...) } // registers flags and binds sub-commands for subnet commands. func init() { cmdSubnetCreate.Flags().Bool(flagSubnetNotary, false, "Flag to create subnet in notary environment") // get subnet flags cmdSubnetGet.Flags().String(flagSubnetGetID, "", "ID of the subnet to read") _ = cmdSubnetAdminAdd.MarkFlagRequired(flagSubnetGetID) // remove subnet flags cmdSubnetRemove.Flags().String(flagSubnetRemoveID, "", "ID of the subnet to remove") _ = cmdSubnetRemove.MarkFlagRequired(flagSubnetRemoveID) // subnet administer flags adminFlags := cmdSubnetAdmin.PersistentFlags() adminFlags.String(flagSubnetAdminSubnet, "", "ID of the subnet to manage administrators") _ = cmdSubnetAdmin.MarkFlagRequired(flagSubnetAdminSubnet) adminFlags.String(flagSubnetAdminID, "", "Hex-encoded public key of the admin") _ = cmdSubnetAdmin.MarkFlagRequired(flagSubnetAdminID) // add admin flags cmdSubnetAdminAddFlags := cmdSubnetAdminAdd.Flags() cmdSubnetAdminAddFlags.String(flagSubnetAdminAddGroup, "", fmt.Sprintf( "Client group ID in text format (needed with --%s only)", flagSubnetAdminClient)) cmdSubnetAdminAddFlags.Bool(flagSubnetAdminClient, false, "Add client admin instead of node one") // remove admin flags cmdSubnetAdminRemoveFlags := cmdSubnetAdminRemove.Flags() cmdSubnetAdminRemoveFlags.Bool(flagSubnetAdminClient, false, "Remove client admin instead of node one") // client managements flags clientFlags := cmdSubnetClient.PersistentFlags() clientFlags.String(flagSubnetClientSubnet, "", "ID of the subnet to be managed") _ = cmdSubnetClient.MarkFlagRequired(flagSubnetClientSubnet) clientFlags.String(flagSubnetClientGroup, "", "ID of the client group to work with") _ = cmdSubnetClient.MarkFlagRequired(flagSubnetClientGroup) clientFlags.String(flagSubnetClientID, "", "Client's user ID in NeoFS system in text format") _ = cmdSubnetClient.MarkFlagRequired(flagSubnetClientID) // add all admin managing commands to corresponding command section addCommandInheritPreRun(cmdSubnetAdmin, cmdSubnetAdminAdd, cmdSubnetAdminRemove, ) // add all client managing commands to corresponding command section addCommandInheritPreRun(cmdSubnetClient, cmdSubnetClientAdd, cmdSubnetClientRemove, ) // subnet node flags nodeFlags := cmdSubnetNode.PersistentFlags() nodeFlags.String(flagSubnetNode, "", "Hex-encoded public key of the node") _ = cmdSubnetAdmin.MarkFlagRequired(flagSubnetNode) nodeFlags.String(flagSubnetNodeSubnet, "", "ID of the subnet to manage nodes") _ = cmdSubnetNode.MarkFlagRequired(flagSubnetNodeSubnet) // add all node managing commands to corresponding command section addCommandInheritPreRun(cmdSubnetNode, cmdSubnetNodeAdd, cmdSubnetNodeRemove, ) // subnet global flags cmdSubnetFlags := cmdSubnet.PersistentFlags() cmdSubnetFlags.StringP(flagSubnetEndpoint, "r", "", "N3 RPC node endpoint") _ = cmdSubnet.MarkFlagRequired(flagSubnetEndpoint) cmdSubnetFlags.StringP(flagSubnetWallet, "w", "", "Path to file with wallet") _ = cmdSubnet.MarkFlagRequired(flagSubnetWallet) cmdSubnetFlags.StringP(flagSubnetAddress, "a", "", "Address in the wallet, optional") // add all subnet commands to corresponding command section addCommandInheritPreRun(cmdSubnet, cmdSubnetCreate, cmdSubnetRemove, cmdSubnetGet, cmdSubnetAdmin, cmdSubnetClient, cmdSubnetNode, ) }