[Utility] Local Proof of Stake CLI - CLI and RPC client [part 1/2] - Issue #112

Makefile

@@ -113,7 +113,7 @@ client_start: docker_check
 .PHONY: client_connect
 ## Connect to the running client debugging daemon
 client_connect: docker_check
-	docker exec -it client /bin/bash -c "go run app/client/*.go"
+	docker exec -it client /bin/bash -c "go run app/client/*.go debug"
 
 .PHONY: build_and_watch
 ## Continous build Pocket's main entrypoint as files change

app/client/cli/account.go

@@ -0,0 +1,61 @@
+package cli
+
+import (
+	"fmt"
+
+	"github.com/pokt-network/pocket/shared/crypto"
+	"github.com/pokt-network/pocket/utility/types"
+	"github.com/spf13/cobra"
+)
+
+func init() {
+	rootCmd.AddCommand(NewAccountCommand())
+}
+
+func NewAccountCommand() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "Account",
+		Short:   "Account specific commands",
+		Aliases: []string{"account"},
+		Args:    cobra.ExactArgs(0),
+	}
+
+	cmd.AddCommand(accountCommands()...)
+
+	return cmd
+}
+
+func accountCommands() (cmds []*cobra.Command) {
+	sendCmd := &cobra.Command{
+		Use:     "Send <fromAddr> <to> <amount>",
+		Short:   "Send <fromAddr> <to> <amount>",
+		Long:    "Sends <amount> to address <to> from address <fromAddr>",
+		Aliases: []string{"send"},
+		Args:    cobra.ExactArgs(3),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			// TODO(pocket/issues/150): update when we have keybase
+			pk, err := readEd25519PrivateKeyFromFile(privateKeyFilePath)
+			if err != nil {
+				return err
+			}
+			// currently ignored since we are using the address from the PrivateKey
+			// fromAddr := crypto.AddressFromString(args[0])
+			toAddr := crypto.AddressFromString(args[1])
+			amount := args[2]
+
+			_ = &types.MessageSend{
+				FromAddress: pk.Address(),
+				ToAddress:   toAddr,
+				Amount:      amount,
+			}
+
+			// TODO(deblasis): implement RPC client, route and handler
+			fmt.Printf("sending %s from %s to %s\n", args[2], args[0], args[1])
+			return nil
+		},
+	}
+
+	cmds = append(cmds, sendCmd)
+
+	return cmds
+}

app/client/cli/actor.go

@@ -0,0 +1,217 @@
+package cli
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"math/big"
+	"regexp"
+	"strings"
+
+	sharedTypes "github.com/pokt-network/pocket/shared/types"
+	"github.com/pokt-network/pocket/utility/types"
+	utilityTypes "github.com/pokt-network/pocket/utility/types"
+	"github.com/spf13/cobra"
+)
+
+func init() {
+	rootCmd.AddCommand(NewActorCommands()...)
+}
+
+var (
+	// DISCUSS(team): this should probably come from somewhere else
+	stakingRecommendationAmount = big.NewInt(15100000000)
+	pwd                         string
+)
+
+type actorCmdDef struct {
+	Name      string
+	ActorType types.ActorType
+}
+
+func NewActorCommands() (cmds []*cobra.Command) {
+	actorCmdDefs := []actorCmdDef{
+		{"Application", types.ActorType_App},
+		{"Node", types.ActorType_Node},
+		{"Fisherman", types.ActorType_Fish},
+		{"Validator", types.ActorType_Val},
+	}
+
+	for _, cmdDef := range actorCmdDefs {
+
+		cmd := &cobra.Command{
+			Use:     cmdDef.Name,
+			Short:   fmt.Sprintf("%s actor specific commands", cmdDef.Name),
+			Aliases: []string{strings.ToLower(cmdDef.Name), cmdDef.ActorType.GetActorName()},
+			Args:    cobra.ExactArgs(0),
+		}
+		cmd.AddCommand(newActorCommands(cmdDef)...)
+		cmds = append(cmds, cmd)
+	}
+
+	return cmds
+}
+
+func newActorCommands(cmdDef actorCmdDef) (cmds []*cobra.Command) {
+	stakeCmd := &cobra.Command{
+		Use:   "Stake <fromAddr> <amount> <RelayChainIDs> <serviceURI>",
+		Short: "Stake a node in the network. Custodial stake uses the same address as operator/output for rewards/return of staked funds.",
+		Long: `Stake the node into the network, making it available for service.
+Will prompt the user for the <fromAddr> account passphrase. If the node is already staked, this transaction acts as an *update* transaction.
+A node can updated relayChainIDs, serviceURI, and raise the stake amount with this transaction.
+If the node is currently staked at X and you submit an update with new stake Y. Only Y-X will be subtracted from an account
+If no changes are desired for the parameter, just enter the current param value just as before`,
+		Args: cobra.ExactArgs(4),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			// TODO(pocket/issues/150): update when we have keybase
+			pk, err := readEd25519PrivateKeyFromFile(privateKeyFilePath)
+			if err != nil {
+				return err
+			}
+			// currently ignored since we are using the address from the PrivateKey
+			// fromAddr := crypto.AddressFromString(args[0])
+			amount := args[1]
+
+			am, err := sharedTypes.StringToBigInt(args[1])
+			if err != nil {
+				log.Fatal(err)
+			}
+
+			if sharedTypes.BigIntLessThan(am, stakingRecommendationAmount) {
+				fmt.Printf("The amount you are staking for is below the recommendation of %d POKT, would you still like to continue? y|n\n", stakingRecommendationAmount.Div(stakingRecommendationAmount, big.NewInt(1000000)).Int64())
+				if !Confirmation(pwd) {
+					return fmt.Errorf("aborted")
+				}
+			}
+
+			reg, err := regexp.Compile("[^,a-fA-F0-9]+")
+			if err != nil {
+				log.Fatal(err)
+			}
+			rawChains := reg.ReplaceAllString(args[2], "")
+			chains := strings.Split(rawChains, ",")
+			serviceURI := args[3]
+
+			fmt.Println("Enter Passphrase: ")
+			// TODO (team): passphrase is currently not used since there's no keybase yet, the prompt is here to mimick the real world UX
+			_ = Credentials(pwd)
+
+			msg := &types.MessageStake{
+				PublicKey:     pk.PublicKey().Bytes(),
+				Chains:        chains,
+				Amount:        amount,
+				ServiceUrl:    serviceURI,
+				OutputAddress: []byte{},     // TODO(deblasis): 👀
+				Signer:        pk.Address(), // TODO(deblasis): figure out where I should get this from (https://github.com/pokt-network/pocket/pull/169#discussion_r953186602)
+				ActorType:     cmdDef.ActorType,
+			}
+
+			codec := sharedTypes.GetCodec()
+			anyMsg, err := codec.ToAny(msg)
+
+			signature, _ := pk.Sign(msg.GetSignBytes())
+
+			tx := &utilityTypes.Transaction{
+				Msg: anyMsg,
+				Signature: &utilityTypes.Signature{
+					Signature: signature,
+					PublicKey: pk.PublicKey().Bytes(),
+				},
+				Nonce: "", // TODO(deblasis): figure out where I should get this from
+			}
+
+			j, err := json.Marshal(tx)
+			if err != nil {
+				return err
+			}
+
+			// TODO(deblasis): we need a single source of truth for routes, the empty string should be replaced with something like a constant that can be used to point to a specific route
+			// perhaps the routes could be centralized into a map[string]Route in #176 and accessed here
+			// I will do this in #169 since it has commits from #176 and #177
+			resp, err := QueryRPC("", j)
+			if err != nil {
+				return err
+			}
+			fmt.Println(resp)
+
+			return nil
+		},
+	}
+	cmds = append(cmds, stakeCmd)
+
+	editStakeCmd := &cobra.Command{
+		Use:   "EditStake <fromAddr> <amount>",
+		Short: "EditStake <fromAddr> <amount>",
+		Long:  fmt.Sprintf(`Stakes a new <amount> for the %s actor with address <fromAddr>`, cmdDef.Name),
+		Args:  cobra.ExactArgs(2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			// TODO(pocket/issues/150): update when we have keybase
+			pk, err := readEd25519PrivateKeyFromFile(privateKeyFilePath)
+			if err != nil {
+				return err
+			}
+
+			amount := args[1]
+
+			_ = &types.MessageEditStake{
+				Address:    pk.Address(),
+				Chains:     []string{}, // TODO(deblasis): 👀
+				Amount:     amount,
+				ServiceUrl: "",       // TODO(deblasis): 👀
+				Signer:     []byte{}, // TODO(deblasis): 👀
+				ActorType:  cmdDef.ActorType,
+			}
+
+			return nil
+		},
+	}
+	cmds = append(cmds, editStakeCmd)
+
+	unstakeCmd := &cobra.Command{
+		Use:   "Unstake <fromAddr>",
+		Short: "Unstake <fromAddr>",
+		Long:  fmt.Sprintf(`Unstakes the prevously staked tokens for the %s actor with address <fromAddr>`, cmdDef.Name),
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			// TODO(pocket/issues/150): update when we have keybase
+			pk, err := readEd25519PrivateKeyFromFile(privateKeyFilePath)
+			if err != nil {
+				return err
+			}
+
+			_ = &types.MessageUnstake{
+				Address:   pk.Address(),
+				Signer:    []byte{}, // TODO(deblasis): 👀
+				ActorType: cmdDef.ActorType,
+			}
+
+			return nil
+		},
+	}
+	cmds = append(cmds, unstakeCmd)
+
+	unpauseCmd := &cobra.Command{
+		Use:   "Unpause <fromAddr>",
+		Short: "Unpause <fromAddr>",
+		Long:  fmt.Sprintf(`Unpauses the %s actor with address <fromAddr>`, cmdDef.Name),
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			// TODO(pocket/issues/150): update when we have keybase
+			pk, err := readEd25519PrivateKeyFromFile(privateKeyFilePath)
+			if err != nil {
+				return err
+			}
+
+			_ = &types.MessageUnpause{
+				Address:   pk.Address(),
+				Signer:    []byte{}, // TODO(deblasis): 👀
+				ActorType: cmdDef.ActorType,
+			}
+
+			return nil
+		},
+	}
+	cmds = append(cmds, unpauseCmd)
+
+	return cmds
+}

app/client/cli/client.go

@@ -0,0 +1,48 @@
+package cli
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"strconv"
+	"time"
+
+	"github.com/pokt-network/pocket/shared/types/genesis/test_artifacts"
+)
+
+func QueryRPC(path string, jsonArgs []byte) (string, error) {
+	cliURL := remoteCLIURL + path
+	fmt.Println(cliURL)
+	req, err := http.NewRequest("POST", cliURL, bytes.NewBuffer(jsonArgs))
+	if err != nil {
+		return "", err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	client := &http.Client{
+		Timeout: time.Duration(test_artifacts.DefaultRpcTimeout) * time.Millisecond,
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+	bz, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+	res, err := strconv.Unquote(string(bz))
+	if err == nil {
+		bz = []byte(res)
+	}
+	if resp.StatusCode == http.StatusOK {
+		var prettyJSON bytes.Buffer
+		err = json.Indent(&prettyJSON, bz, "", "    ")
+		if err == nil {
+			return prettyJSON.String(), nil
+		}
+		return string(bz), nil
+	}
+	return "", fmt.Errorf("the http status code was not okay: %d, and the status was: %s, with a response of %v", resp.StatusCode, resp.Status, string(bz))
+}

app/client/cli/cmd.go

@@ -0,0 +1,33 @@
+package cli
+
+import (
+	"context"
+
+	"github.com/pokt-network/pocket/shared/types/genesis/test_artifacts"
+	"github.com/spf13/cobra"
+)
+
+const cliExecutableName = "client"
+
+var (
+	remoteCLIURL       string
+	privateKeyFilePath string
+)
+
+func init() {
+	rootCmd.PersistentFlags().StringVar(&remoteCLIURL, "remoteCLIURL", test_artifacts.DefaultRemoteCliUrl, "takes a remote endpoint in the form of <protocol>://<host> (uses RPC Port)")
+	rootCmd.PersistentFlags().StringVar(&privateKeyFilePath, "path_to_private_key_file", "./pk.json", "Path to private key to use when signing")
+}
+
+var rootCmd = &cobra.Command{
+	Use: cliExecutableName,
+	// TODO(deblasis): document
+	Short: "",
+	Long:  "",
+	// TODO(deblasis): do we need some sort of teardown as well?
+
+}
+
+func ExecuteContext(ctx context.Context) error {
+	return rootCmd.ExecuteContext(ctx)
+}