NFT Module

x/nfts/client/cli/parse.go

@@ -0,0 +1,44 @@
+package cli
+
+import (
+	"github.com/spf13/viper"
+
+	"github.com/cosmos/cosmos-sdk/x/nfts"
+)
+
+const (
+	flagName        = "name"
+	flagDescription = "description"
+	flagImage       = "image"
+	flagTokenURI    = "tokenURI"
+)
+
+func parseEditMetadataFlags() (nfts.MsgEditNFTMetadata, error) {
+	msg := nfts.MsgEditNFTMetadata{}
+
+	name := viper.GetString(flagName)
+	if name != "" {
+		msg.EditName = true
+		msg.Name = name
+	}
+
+	description := viper.GetString(flagDescription)
+	if description != "" {
+		msg.EditDescription = true
+		msg.Description = description
+	}
+
+	image := viper.GetString(flagImage)
+	if image != "" {
+		msg.EditImage = true
+		msg.Image = image
+	}
+
+	tokenURI := viper.GetString(flagTokenURI)
+	if tokenURI != "" {
+		msg.EditTokenURI = true
+		msg.TokenURI = tokenURI
+	}
+
+	return msg, nil
+}

x/nfts/client/cli/query.go

@@ -0,0 +1,109 @@
+package cli
+
+import (
+	"fmt"
+
+	"github.com/cosmos/cosmos-sdk/client/context"
+	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/x/nfts"
+	"github.com/spf13/cobra"
+)
+
+// GetCmdQueryCollectionSupply queries the supply of a nft collection
+func GetCmdQueryCollectionSupply(queryRoute string, cdc *codec.Codec) *cobra.Command {
+	return &cobra.Command{
+		Use:   "supply [denom]",
+		Short: "total supply of a collection of NFTs",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			cliCtx := context.NewCLIContext().WithCodec(cdc)
+			denom := args[0]
+
+			res, err := cliCtx.QueryWithData(fmt.Sprintf("custom/%s/supply/%s", queryRoute, denom), nil)
+			if err != nil {
+				fmt.Printf("could not query supply of %s\n", denom)
+				fmt.Print(err.Error())
+				return nil
+			}
+
+			// var out nfts.NFT
+			// cdc.MustUnmarshalJSON(res, &out)
+			// return cliCtx.PrintOutput(out)
+		},
+	}
+}
+
+// GetCmdQueryBalance queries all the NFTs owned by an account
+func GetCmdQueryBalance(queryRoute string, cdc *codec.Codec) *cobra.Command {
+	return &cobra.Command{
+		Use:   "balance [accountAddress] [denom]",
+		Short: "get the NFTs owned by an account address",
+		Long:  "get the NFTs owned by an account address", // TODO: finish this
+		Args:  cobra.RangeArgs(1, 2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			cliCtx := context.NewCLIContext().WithCodec(cdc)
+			account := args[0]
+
+			res, err := cliCtx.QueryWithData(fmt.Sprintf("custom/%s/balance/%s", queryRoute, account), nil)
+			if err != nil {
+				fmt.Printf("could not query %s balance of account %s \n", denom, account)
+				fmt.Print(err.Error())
+				return nil
+			}
+
+			var out nfts.QueryResBalance
+			cdc.MustUnmarshalJSON(res, &out)
+			return cliCtx.PrintOutput(out)
+		},
+	}
+}
+
+// GetCmdQueryNFTs queries all the NFTs from a collection
+func GetCmdQueryNFTs(queryRoute string, cdc *codec.Codec) *cobra.Command {
+	return &cobra.Command{
+		Use:   "collection [denom]",
+		Short: "get all the NFTs from a given collection",
+		Args:  cobra.ExactArgs(2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			cliCtx := context.NewCLIContext().WithCodec(cdc)
+			denom := args[0]
+			tokenID := args[1]
+
+			res, err := cliCtx.QueryWithData(fmt.Sprintf("custom/%s/collection/%s", queryRoute, denom, tokenID), nil)
+			if err != nil {
+				fmt.Printf("could not query owner of %s #%s\n", denom, tokenID)
+				fmt.Print(err.Error())
+				return nil
+			}
+
+			var out nfts.QueryResOwnerOf
+			cdc.MustUnmarshalJSON(res, &out)
+			return cliCtx.PrintOutput(out)
+		},
+	}
+}
+
+// GetCmdQueryNFT queries a single NFTs from a collection
+func GetCmdQueryNFT(queryRoute string, cdc *codec.Codec) *cobra.Command {
+	return &cobra.Command{
+		Use:   "nft [denom] [ID]",
+		Short: "query a single NFT from a collection",
+		Args:  cobra.ExactArgs(2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			cliCtx := context.NewCLIContext().WithCodec(cdc)
+			denom := args[0]
+			ID := args[1]
+
+			res, err := cliCtx.QueryWithData(fmt.Sprintf("custom/%s/nft/%s/%s", queryRoute, denom, tokenID), nil)
+			if err != nil {
+				fmt.Printf("could not query owner of %s #%s\n", denom, tokenID)
+				fmt.Print(err.Error())
+				return nil
+			}
+
+			var out nfts.QueryResOwnerOf
+			cdc.MustUnmarshalJSON(res, &out)
+			return cliCtx.PrintOutput(out)
+		},
+	}
+}

x/nfts/client/cli/tx.go

@@ -0,0 +1,184 @@
+package cli
+
+import (
+	"strconv"
+
+	"github.com/cosmos/cosmos-sdk/client/context"
+	"github.com/cosmos/cosmos-sdk/client/utils"
+	"github.com/cosmos/cosmos-sdk/codec"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	authtxb "github.com/cosmos/cosmos-sdk/x/auth/client/txbuilder"
+	"github.com/cosmos/cosmos-sdk/x/nfts"
+	"github.com/spf13/cobra"
+)
+
+// GetCmdTransferNFT is the CLI command for sending a TransferNFT transaction
+func GetCmdTransferNFT(cdc *codec.Codec) *cobra.Command {
+	return &cobra.Command{
+		Use:   "transfer [sender] [recipient] [denom] [tokenID]",
+		Short: "transfer a token of some denom with some tokenID to some recipient",
+		Args:  cobra.ExactArgs(4),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			cliCtx := context.NewCLIContext().WithCodec(cdc).WithAccountDecoder(cdc)
+
+			txBldr := authtxb.NewTxBuilderFromCLI().WithTxEncoder(utils.GetTxEncoder(cdc))
+
+			// TODO: Does this need to be true? What does it mean to have an account that doesn't exist?
+			// If it just means having a balance in some token then no, an account doens't need to "exist".
+			if err := cliCtx.EnsureAccountExists(); err != nil {
+				return err
+			}
+
+			tokenID, err := strconv.ParseUint(args[2], 10, 64)
+			if err != nil {
+				return err
+			}
+
+			msg := nfts.NewMsgTransferNFT(cliCtx.GetFromAddress(), sdk.AccAddress(args[0]), nfts.Denom(args[1]), nfts.TokenID(tokenID))
+			err = msg.ValidateBasic()
+			if err != nil {
+				return err
+			}
+
+			cliCtx.PrintResponse = true
+
+			return utils.GenerateOrBroadcastMsgs(cliCtx, txBldr, []sdk.Msg{msg}, false)
+		},
+	}
+}
+
+// GetCmdEditNFTMetadata is the CLI command for a EditNFTMetadata transaction
+func GetCmdEditNFTMetadata(cdc *codec.Codec) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "edit-metadata [denom] [tokenID]",
+		Short: "transfer a token of some denom with some tokenID to some recipient",
+		Args:  cobra.ExactArgs(2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+
+			msg, err := parseEditMetadataFlags()
+			if err != nil {
+				return err
+			}
+
+			cliCtx := context.NewCLIContext().WithCodec(cdc).WithAccountDecoder(cdc)
+			txBldr := authtxb.NewTxBuilderFromCLI().WithTxEncoder(utils.GetTxEncoder(cdc))
+
+			tokenID, err := strconv.ParseUint(args[1], 10, 64)
+			if err != nil {
+				return err
+			}
+
+			msg = nfts.NewMsgEditNFTMetadata(cliCtx.GetFromAddress(),
+				nfts.Denom(args[0]),
+				nfts.TokenID(tokenID),
+				msg.EditName,
+				msg.EditDescription,
+				msg.EditImage,
+				msg.EditTokenURI,
+				msg.Name,
+				msg.Description,
+				msg.Image,
+				msg.TokenURI,
+			)
+			err = msg.ValidateBasic()
+			if err != nil {
+				return err
+			}
+
+			cliCtx.PrintResponse = true
+
+			return utils.GenerateOrBroadcastMsgs(cliCtx, txBldr, []sdk.Msg{msg}, false)
+		},
+	}
+
+	cmd.Flags().String(flagName, "", "Name/title of nft")
+	cmd.Flags().String(flagDescription, "", "Description of nft")
+	cmd.Flags().String(flagImage, "", "Image uri of nft")
+	cmd.Flags().String(flagTokenURI, "", "URI for supplemental off-chain metadata (should return a JSON object)")
+
+	return cmd
+}
+
+// GetCmdMintNFT is the CLI command for a MintNFT transaction
+func GetCmdMintNFT(cdc *codec.Codec) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "mint [recipient] [denom] [tokenID]",
+		Short: "mints a token of some denom with some tokenID to some recipient",
+		Args:  cobra.ExactArgs(3),
+		RunE: func(cmd *cobra.Command, args []string) error {
+
+			metadata, err := parseEditMetadataFlags()
+			if err != nil {
+				return err
+			}
+
+			cliCtx := context.NewCLIContext().WithCodec(cdc).WithAccountDecoder(cdc)
+			txBldr := authtxb.NewTxBuilderFromCLI().WithTxEncoder(utils.GetTxEncoder(cdc))
+
+			tokenID, err := strconv.ParseUint(args[2], 10, 64)
+			if err != nil {
+				return err
+			}
+
+			msg := nfts.NewMsgMintNFT(cliCtx.GetFromAddress(),
+				sdk.AccAddress(args[0]),
+				nfts.TokenID(tokenID),
+				nfts.Denom(args[1]),
+				metadata.Name,
+				metadata.Description,
+				metadata.Image,
+				metadata.TokenURI,
+			)
+			err = msg.ValidateBasic()
+			if err != nil {
+				return err
+			}
+
+			cliCtx.PrintResponse = true
+
+			return utils.GenerateOrBroadcastMsgs(cliCtx, txBldr, []sdk.Msg{msg}, false)
+		},
+	}
+
+	cmd.Flags().String(flagName, "", "Name/title of nft")
+	cmd.Flags().String(flagDescription, "", "Description of nft")
+	cmd.Flags().String(flagImage, "", "Image uri of nft")
+	cmd.Flags().String(flagTokenURI, "", "URI for supplemental off-chain metadata (should return a JSON object)")
+
+	return cmd
+}
+
+// GetCmdBurnNFT is the CLI command for sending a BurnNFT transaction
+func GetCmdBurnNFT(cdc *codec.Codec) *cobra.Command {
+	return &cobra.Command{
+		Use:   "burn [denom] [tokenID]",
+		Short: "burn a token of some denom with some tokenID",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			cliCtx := context.NewCLIContext().WithCodec(cdc).WithAccountDecoder(cdc)
+
+			txBldr := authtxb.NewTxBuilderFromCLI().WithTxEncoder(utils.GetTxEncoder(cdc))
+
+			// TODO: Does this need to be true? What does it mean to have an account that doesn't exist?
+			// If it just means having a balance in some token then no, an account doens't need to "exist".
+			if err := cliCtx.EnsureAccountExists(); err != nil {
+				return err
+			}
+
+			tokenID, err := strconv.ParseUint(args[1], 10, 64)
+			if err != nil {
+				return err
+			}
+
+			msg := nfts.NewMsgBurnNFT(cliCtx.GetFromAddress(), nfts.TokenID(tokenID), nfts.Denom(args[1]))
+			err = msg.ValidateBasic()
+			if err != nil {
+				return err
+			}
+
+			cliCtx.PrintResponse = true
+
+			return utils.GenerateOrBroadcastMsgs(cliCtx, txBldr, []sdk.Msg{msg}, false)
+		},
+	}
+}

x/nfts/client/module_client.go

@@ -0,0 +1,54 @@
+package client
+
+import (
+	"github.com/cosmos/cosmos-sdk/client"
+	nftcmd "github.com/cosmos/cosmos-sdk/x/nfts/client/cli"
+	"github.com/spf13/cobra"
+
+	amino "github.com/tendermint/go-amino"
+)
+
+// ModuleClient exports all client functionality from this module
+type ModuleClient struct {
+	storeKey string
+	cdc      *amino.Codec
+}
+
+// NewModuleClient creates a new module client
+func NewModuleClient(storeKey string, cdc *amino.Codec) ModuleClient {
+	return ModuleClient{storeKey, cdc}
+}
+
+// GetQueryCmd returns the cli query commands for this module
+func (mc ModuleClient) GetQueryCmd() *cobra.Command {
+	// Group nameservice queries under a subcommand
+	nftQueryCmd := &cobra.Command{
+		Use:   "nft",
+		Short: "Querying commands for the NFT module",
+	}
+
+	nftQueryCmd.AddCommand(client.GetCommands(
+		nftcmd.GetCmdQueryBalanceOf(mc.storeKey, mc.cdc),
+		nftcmd.GetCmdQueryOwnerOf(mc.storeKey, mc.cdc),
+		nftcmd.GetCmdQueryMetadata(mc.storeKey, mc.cdc),
+	)...)
+
+	return nftQueryCmd
+}
+
+// GetTxCmd returns the transaction commands for this module
+func (mc ModuleClient) GetTxCmd() *cobra.Command {
+	nftTxCmd := &cobra.Command{
+		Use:   "nft",
+		Short: "Non-FungibleToken transactions subcommands",
+	}
+
+	nftTxCmd.AddCommand(client.PostCommands(
+		nftcmd.GetCmdTransferNFT(mc.cdc),
+		nftcmd.GetCmdEditNFTMetadata(mc.cdc),
+		nftcmd.GetCmdMintNFT(mc.cdc),
+		nftcmd.GetCmdBurnNFT(mc.cdc),
+	)...)
+
+	return nftTxCmd
+}