cli: add nep11 [tokens | tokensOf | ownerOf] commands

cli/nep11_test.go

@@ -115,27 +115,32 @@ func TestNEP11_OwnerOf_BalanceOf_Transfer(t *testing.T) {
 	// deploy NFT HASHY contract
 	h := deployNFTContract(t, e)
 
-	// mint 1 HASHY token by transferring 10 GAS to HASHY contract
+	mint := func(t *testing.T) []byte {
-	e.In.WriteString(nftOwnerPass + "\r")
+		// mint 1 HASHY token by transferring 10 GAS to HASHY contract
-	e.Run(t, "neo-go", "wallet", "nep17", "transfer",
+		e.In.WriteString(nftOwnerPass + "\r")
-		"--rpc-endpoint", "http://"+e.RPC.Addr,
+		e.Run(t, "neo-go", "wallet", "nep17", "transfer",
-		"--wallet", wall,
+			"--rpc-endpoint", "http://"+e.RPC.Addr,
-		"--to", h.StringLE(),
+			"--wallet", wall,
-		"--token", "GAS",
+			"--to", h.StringLE(),
-		"--amount", "10",
+			"--token", "GAS",
-		"--from", nftOwnerAddr)
+			"--amount", "10",
-	txMint, _ := e.checkTxPersisted(t)
+			"--from", nftOwnerAddr)
+		txMint, _ := e.checkTxPersisted(t)
 
-	// get NFT ID from AER
+		// get NFT ID from AER
-	aer, err := e.Chain.GetAppExecResults(txMint.Hash(), trigger.Application)
+		aer, err := e.Chain.GetAppExecResults(txMint.Hash(), trigger.Application)
-	require.NoError(t, err)
+		require.NoError(t, err)
-	require.Equal(t, 1, len(aer))
+		require.Equal(t, 1, len(aer))
-	require.Equal(t, 2, len(aer[0].Events))
+		require.Equal(t, 2, len(aer[0].Events))
-	hashyMintEvent := aer[0].Events[1]
+		hashyMintEvent := aer[0].Events[1]
-	require.Equal(t, "Transfer", hashyMintEvent.Name)
+		require.Equal(t, "Transfer", hashyMintEvent.Name)
-	tokenID, err := hashyMintEvent.Item.Value().([]stackitem.Item)[3].TryBytes()
+		tokenID, err := hashyMintEvent.Item.Value().([]stackitem.Item)[3].TryBytes()
-	require.NoError(t, err)
+		require.NoError(t, err)
-	require.NotNil(t, tokenID)
+		require.NotNil(t, tokenID)
+		return tokenID
+	}
+
+	tokenID := mint(t)
 
 	// check the balance
 	cmdCheckBalance := []string{"neo-go", "wallet", "nep11", "balance",
@@ -191,6 +196,43 @@ func TestNEP11_OwnerOf_BalanceOf_Transfer(t *testing.T) {
 	e.Run(t, cmdOwnerOf...)
 	e.checkNextLine(t, nftOwnerAddr)
 
+	// tokensOf: missing contract hash
+	cmdTokensOf := []string{"neo-go", "wallet", "nep11", "tokensOf",
+		"--rpc-endpoint", "http://" + e.RPC.Addr,
+	}
+	e.RunWithError(t, cmdTokensOf...)
+	cmdTokensOf = append(cmdTokensOf, "--token", h.StringLE())
+
+	// tokensOf: missing owner address
+	e.RunWithError(t, cmdTokensOf...)
+	cmdTokensOf = append(cmdTokensOf, "--address", nftOwnerAddr)
+
+	// tokensOf: good
+	e.Run(t, cmdTokensOf...)
+	e.checkNextLine(t, string(tokenID))
+
+	// tokensOf: good, several tokens
+	tokenID1 := mint(t)
+	e.Run(t, cmdTokensOf...)
+	e.checkNextLine(t, string(tokenID))
+	e.checkNextLine(t, string(tokenID1))
+
+	// tokens: missing contract hash
+	cmdTokens := []string{"neo-go", "wallet", "nep11", "tokens",
+		"--rpc-endpoint", "http://" + e.RPC.Addr,
+	}
+	e.RunWithError(t, cmdTokens...)
+	cmdTokens = append(cmdTokens, "--token", h.StringLE())
+
+	// tokens: good, several tokens
+	e.Run(t, cmdTokens...)
+	e.checkNextLine(t, string(tokenID))
+	e.checkNextLine(t, string(tokenID1))
+
+	// balance check: several tokens, ok
+	e.Run(t, append(cmdCheckBalance, "--token", h.StringLE())...)
+	checkBalanceResult(t, nftOwnerAddr, "2")
+
 	cmdTransfer := []string{
 		"neo-go", "wallet", "nep11", "transfer",
 		"--rpc-endpoint", "http://" + e.RPC.Addr,
@@ -217,7 +259,7 @@ func TestNEP11_OwnerOf_BalanceOf_Transfer(t *testing.T) {
 
 	// check balance after transfer
 	e.Run(t, append(cmdCheckBalance, "--token", h.StringLE())...)
-	checkBalanceResult(t, nftOwnerAddr, "0")
+	checkBalanceResult(t, nftOwnerAddr, "1") // tokenID1
 }
 
 func deployNFTContract(t *testing.T, e *executor) util.Uint160 {

cli/wallet/nep11.go

@@ -23,6 +23,10 @@ func newNEP11Commands() []cli.Command {
 		Name:  "token",
 		Usage: "Token contract address or hash in LE",
 	}
+	ownerAddressFlag := flags.AddressFlag{
+		Name:  "address",
+		Usage: "NFT owner address or hash in LE",
+	}
 	tokenID := cli.StringFlag{
 		Name:  "id",
 		Usage: "Token ID",
@@ -97,6 +101,25 @@ func newNEP11Commands() []cli.Command {
 				tokenID,
 			}, options.RPC...),
 		},
+		{
+			Name:      "tokensOf",
+			Usage:     "print list of tokens IDs for the specified divisible NFT owner",
+			UsageText: "tokensOf --rpc-endpoint <node> --timeout <time> --token <hash> --address <addr>",
+			Action:    printNEP11TokensOf,
+			Flags: append([]cli.Flag{
+				tokenAddressFlag,
+				ownerAddressFlag,
+			}, options.RPC...),
+		},
+		{
+			Name:      "tokens",
+			Usage:     "print list of tokens IDs minted by the specified NFT (optional method)",
+			UsageText: "tokens --rpc-endpoint <node> --timeout <time> --token <hash>",
+			Action:    printNEP11Tokens,
+			Flags: append([]cli.Flag{
+				tokenAddressFlag,
+			}, options.RPC...),
+		},
 	}
 }
 
@@ -264,3 +287,60 @@ func printNEP11Owner(ctx *cli.Context) error {
 	fmt.Fprintln(ctx.App.Writer, address.Uint160ToString(result))
 	return nil
 }
+
+func printNEP11TokensOf(ctx *cli.Context) error {
+	var err error
+	tokenHash := ctx.Generic("token").(*flags.Address)
+	if !tokenHash.IsSet {
+		return cli.NewExitError("token contract hash was not set", 1)
+	}
+
+	acc := ctx.Generic("address").(*flags.Address)
+	if !acc.IsSet {
+		return cli.NewExitError("owner address flag was not set", 1)
+	}
+
+	gctx, cancel := options.GetTimeoutContext(ctx)
+	defer cancel()
+
+	c, err := options.GetRPCClient(gctx, ctx)
+	if err != nil {
+		return cli.NewExitError(err, 1)
+	}
+
+	result, err := c.NEP11TokensOf(tokenHash.Uint160(), acc.Uint160())
+	if err != nil {
+		return cli.NewExitError(fmt.Sprintf("failed to call NEP11 `tokensOf` method: %s", err.Error()), 1)
+	}
+
+	for i := range result {
+		fmt.Fprintln(ctx.App.Writer, result[i])
+	}
+	return nil
+}
+
+func printNEP11Tokens(ctx *cli.Context) error {
+	var err error
+	tokenHash := ctx.Generic("token").(*flags.Address)
+	if !tokenHash.IsSet {
+		return cli.NewExitError("token contract hash was not set", 1)
+	}
+
+	gctx, cancel := options.GetTimeoutContext(ctx)
+	defer cancel()
+
+	c, err := options.GetRPCClient(gctx, ctx)
+	if err != nil {
+		return cli.NewExitError(err, 1)
+	}
+
+	result, err := c.NEP11Tokens(tokenHash.Uint160())
+	if err != nil {
+		return cli.NewExitError(fmt.Sprintf("failed to call optional NEP11 `tokens` method: %s", err.Error()), 1)
+	}
+
+	for i := range result {
+		fmt.Fprintln(ctx.App.Writer, result[i])
+	}
+	return nil
+}