Merge branch 'master' into khalil/1659-secure-grpc-support

Author: kc1116

go.mod

@@ -4,12 +4,13 @@ go 1.13
 
 require (
 	github.com/a8m/envsubst v1.2.0
+	github.com/getsentry/sentry-go v0.12.0
 	github.com/go-git/go-git/v5 v5.4.2
 	github.com/gosuri/uilive v0.0.4
 	github.com/joho/godotenv v1.4.0
 	github.com/manifoldco/promptui v0.9.0
 	github.com/onflow/cadence v0.20.2
-	github.com/onflow/cadence/languageserver v0.18.3-0.20211005105715-3c618f0fcd10
+	github.com/onflow/cadence/languageserver v0.18.3-0.20220126162456-79571a12b7ff
 	github.com/onflow/flow-core-contracts/lib/go/templates v0.7.9
 	github.com/onflow/flow-emulator v0.27.3
 	github.com/onflow/flow-go v0.23.4

go.sum

@@ -36,8 +36,8 @@ type flagsCreate struct {
 	Signer    string   `default:"emulator-account" flag:"signer" info:"Account name from configuration used to sign the transaction"`
 	Keys      []string `flag:"key" info:"Public keys to attach to account"`
 	Weights   []int    `flag:"key-weight" info:"Weight for the key"`
-	SigAlgo   string   `default:"ECDSA_P256" flag:"sig-algo" info:"Signature algorithm used to generate the keys"`
-	HashAlgo  string   `default:"SHA3_256" flag:"hash-algo" info:"Hash used for the digest"`
+	SigAlgo   []string `default:"ECDSA_P256" flag:"sig-algo" info:"Signature algorithm used to generate the keys"`
+	HashAlgo  []string `default:"SHA3_256" flag:"hash-algo" info:"Hash used for the digest"`
 	Contracts []string `flag:"contract" info:"Contract to be deployed during account creation. <name:filename>"`
 	Include   []string `default:"" flag:"include" info:"Fields to include in the output"`
 }
@@ -66,23 +66,50 @@ func create(
 		return nil, err
 	}
 
-	sigAlgo := crypto.StringToSignatureAlgorithm(createFlags.SigAlgo)
-	if sigAlgo == crypto.UnknownSignatureAlgorithm {
-		return nil, fmt.Errorf("invalid signature algorithm: %s", createFlags.SigAlgo)
+	if len(createFlags.SigAlgo) == 1 && len(createFlags.HashAlgo) == 1 {
+		// Fill up depending on size of key input
+		if len(createFlags.Keys) > 1 {
+			for i := 1; i < len(createFlags.Keys); i++ {
+				createFlags.SigAlgo = append(createFlags.SigAlgo, createFlags.SigAlgo[0])
+				createFlags.HashAlgo = append(createFlags.HashAlgo, createFlags.HashAlgo[0])
+			}
+			// Deprecated usage message?
+		}
+
+	} else
+	// double check matching array lengths on inputs
+	if len(createFlags.Keys) != len(createFlags.SigAlgo) || len(createFlags.SigAlgo) != len(createFlags.HashAlgo) {
+		return nil, fmt.Errorf("must provide a signature and hash algorithm for every key provided to --key: %d keys, %d signature algo, %d hash algo", len(createFlags.Keys), len(createFlags.SigAlgo), len(createFlags.HashAlgo))
 	}
 
-	hashAlgo := crypto.StringToHashAlgorithm(createFlags.HashAlgo)
-	if hashAlgo == crypto.UnknownHashAlgorithm {
-		return nil, fmt.Errorf("invalid hash algorithm: %s", createFlags.HashAlgo)
+	// read all signature algorithms
+	sigAlgos := make([]crypto.SignatureAlgorithm, 0, len(createFlags.SigAlgo))
+	for _, sigAlgoStr := range createFlags.SigAlgo {
+		sigAlgo := crypto.StringToSignatureAlgorithm(sigAlgoStr)
+		if sigAlgo == crypto.UnknownSignatureAlgorithm {
+			return nil, fmt.Errorf("invalid signature algorithm: %s", createFlags.SigAlgo)
+		}
+		sigAlgos = append(sigAlgos, sigAlgo)
+	}
+
+	// read all hash algorithms
+	hashAlgos := make([]crypto.HashAlgorithm, 0, len(createFlags.HashAlgo))
+	for _, hashAlgoStr := range createFlags.HashAlgo {
+
+		hashAlgo := crypto.StringToHashAlgorithm(hashAlgoStr)
+		if hashAlgo == crypto.UnknownHashAlgorithm {
+			return nil, fmt.Errorf("invalid hash algorithm: %s", createFlags.HashAlgo)
+		}
+		hashAlgos = append(hashAlgos, hashAlgo)
 	}
 
 	keyWeights := createFlags.Weights
 
 	// decode public keys
-	var pubKeys []crypto.PublicKey
-	for _, k := range createFlags.Keys {
+	pubKeys := make([]crypto.PublicKey, 0, len(createFlags.Keys))
+	for i, k := range createFlags.Keys {
 		k = strings.TrimPrefix(k, "0x") // clear possible prefix
-		key, err := crypto.DecodePublicKeyHex(sigAlgo, k)
+		key, err := crypto.DecodePublicKeyHex(sigAlgos[i], k)
 		if err != nil {
 			return nil, fmt.Errorf("failed decoding public key: %s with error: %w", key, err)
 		}
@@ -93,8 +120,8 @@ func create(
 		signer,
 		pubKeys,
 		keyWeights,
-		sigAlgo,
-		hashAlgo,
+		sigAlgos,
+		hashAlgos,
 		createFlags.Contracts,
 	)
 

internal/accounts/create.go

@@ -36,6 +36,8 @@ import (
 	"github.com/onflow/flow-cli/pkg/flowkit/services"
 	"github.com/onflow/flow-cli/pkg/flowkit/util"
 
+	"github.com/getsentry/sentry-go"
+	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
 )
 
@@ -81,7 +83,13 @@ const (
 // here we can do all boilerplate code that is else copied in each command and make sure
 // we have one place to handle all errors and ensure commands have consistent results.
 func (c Command) AddToParent(parent *cobra.Command) {
+	// initialize crash reporting for the CLI
+	initCrashReporting()
+
 	c.Cmd.Run = func(cmd *cobra.Command, args []string) {
+		defer sentry.Flush(2 * time.Second)
+		defer sentry.Recover()
+
 		// initialize file loader used in commands
 		loader := &afero.Afero{Fs: afero.NewOsFs()}
 
@@ -189,7 +197,6 @@ func resolveHost(state *flowkit.State, hostFlag, networkKeyFlag, networkFlag str
 	}
 
 	return network.Host, network.Key, nil
-
 }
 
 // create logger utility.
@@ -247,3 +254,29 @@ func checkVersion(logger output.Logger) {
 		))
 	}
 }
+
+// initCrashReporting set-ups sentry as crash reporting tool, it also sets listener for panics
+// and asks before sending the error for a permission to do so from the user.
+func initCrashReporting() {
+	currentVersion := build.Semver()
+
+	err := sentry.Init(sentry.ClientOptions{
+		Dsn:              "https://a3d7d72b79ff49ce808e241ccc5bf111@o1129322.ingest.sentry.io/6173086",
+		Environment:      "Dev",
+		Release:          currentVersion,
+		AttachStacktrace: true,
+		BeforeSend: func(event *sentry.Event, hint *sentry.EventHint) *sentry.Event {
+			// ask for crash report permission
+			fmt.Printf("\n%s Crash detected! %s\n\n", output.ErrorEmoji(), event.Message)
+
+			if output.ReportCrash() {
+				return event
+			}
+
+			return nil
+		},
+	})
+	if err != nil {
+		fmt.Println(err) // safest output method at this point
+	}
+}

internal/command/command.go

@@ -32,6 +32,8 @@ import (
 	"github.com/onflow/flow-cli/pkg/flowkit/util"
 )
 
+const faucetHost = "https://testnet-faucet.onflow.org/"
+
 var Cmd = &cobra.Command{
 	Use:              "keys",
 	Short:            "Utilities to manage keys",
@@ -65,6 +67,18 @@ func (k *KeyResult) String() string {
 	writer := util.CreateTabWriter(&b)
 
 	if k.privateKey != nil {
+		// build the faucet link
+		link := fmt.Sprintf("%s?key=%x", faucetHost, k.publicKey.Encode())
+		if k.privateKey.Algorithm() != crypto.ECDSA_P256 {
+			link = fmt.Sprintf("%s&sig-algo=%s", link, k.privateKey.Algorithm().String())
+		}
+
+		fmt.Printf(
+			"%s If you want to create an account on testnet with the generated keys use this link:\n%s \n\n",
+			output.TryEmoji(),
+			link,
+		)
+
 		_, _ = fmt.Fprintf(writer, "%s Store private key safely and don't share with anyone! \n", output.StopEmoji())
 		_, _ = fmt.Fprintf(writer, "Private Key \t %x \n", k.privateKey.Encode())
 	}

internal/keys/keys.go

@@ -497,3 +497,13 @@ func RemoveNetworkPrompt(networks config.Networks) string {
 
 	return name
 }
+
+func ReportCrash() bool {
+	prompt := promptui.Select{
+		Label: "🙏 Please report the crash so we can improve the CLI. Do you want to report it?",
+		Items: []string{"Yes, report the crash", "No"},
+	}
+	chosen, _, _ := prompt.Run()
+
+	return chosen == 0
+}

pkg/flowkit/output/prompt.go

@@ -178,8 +178,8 @@ func (a *Accounts) Create(
 	signer *flowkit.Account,
 	pubKeys []crypto.PublicKey,
 	keyWeights []int,
-	sigAlgo crypto.SignatureAlgorithm,
-	hashAlgo crypto.HashAlgorithm,
+	sigAlgo []crypto.SignatureAlgorithm,
+	hashAlgo []crypto.HashAlgorithm,
 	contractArgs []string,
 ) (*flow.Account, error) {
 	if a.state == nil {
@@ -204,8 +204,8 @@ func (a *Accounts) Create(
 
 		accKey := &flow.AccountKey{
 			PublicKey: pubKey,
-			SigAlgo:   sigAlgo,
-			HashAlgo:  hashAlgo,
+			SigAlgo:   sigAlgo[i],
+			HashAlgo:  hashAlgo[i],
 			Weight:    weight,
 		}
 

pkg/flowkit/services/accounts.go

@@ -98,8 +98,8 @@ func TestAccounts(t *testing.T) {
 			serviceAcc,
 			[]crypto.PublicKey{pubKey},
 			[]int{1000},
-			crypto.ECDSA_P256,
-			crypto.SHA3_256,
+			[]crypto.SignatureAlgorithm{crypto.ECDSA_P256},
+			[]crypto.HashAlgorithm{crypto.SHA3_256},
 			nil,
 		)
 
@@ -134,8 +134,8 @@ func TestAccounts(t *testing.T) {
 			serviceAcc,
 			[]crypto.PublicKey{pubKey},
 			[]int{1000},
-			crypto.ECDSA_P256,
-			crypto.SHA3_256,
+			[]crypto.SignatureAlgorithm{crypto.ECDSA_P256},
+			[]crypto.HashAlgorithm{crypto.SHA3_256},
 			[]string{"Hello:contractHello.cdc"},
 		)
 
@@ -296,8 +296,8 @@ func TestAccountsCreate_Integration(t *testing.T) {
 		account  *flowkit.Account
 		pubKeys  []crypto.PublicKey
 		weights  []int
-		sigAlgo  crypto.SignatureAlgorithm
-		hashAlgo crypto.HashAlgorithm
+		sigAlgo  []crypto.SignatureAlgorithm
+		hashAlgo []crypto.HashAlgorithm
 		args     []string
 	}
 
@@ -316,19 +316,29 @@ func TestAccountsCreate_Integration(t *testing.T) {
 		srvAcc, _ := state.EmulatorServiceAccount()
 
 		accIn := []accountsIn{{
-			account:  srvAcc,
-			sigAlgo:  crypto.ECDSA_P256,
-			hashAlgo: crypto.SHA3_256,
-			args:     nil,
+			account: srvAcc,
+			sigAlgo: []crypto.SignatureAlgorithm{
+				tests.SigAlgos()[0],
+			},
+			hashAlgo: []crypto.HashAlgorithm{
+				tests.HashAlgos()[0],
+			},
+			args: nil,
 			pubKeys: []crypto.PublicKey{
 				tests.PubKeys()[0],
 			},
 			weights: []int{flow.AccountKeyWeightThreshold},
 		}, {
-			account:  srvAcc,
-			args:     nil,
-			sigAlgo:  crypto.ECDSA_P256,
-			hashAlgo: crypto.SHA3_256,
+			account: srvAcc,
+			args:    nil,
+			sigAlgo: []crypto.SignatureAlgorithm{
+				tests.SigAlgos()[0],
+				tests.SigAlgos()[1],
+			},
+			hashAlgo: []crypto.HashAlgorithm{
+				tests.HashAlgos()[0],
+				tests.HashAlgos()[1],
+			},
 			pubKeys: []crypto.PublicKey{
 				tests.PubKeys()[0],
 				tests.PubKeys()[1],
@@ -342,8 +352,12 @@ func TestAccountsCreate_Integration(t *testing.T) {
 					tests.ContractSimple.Filename,
 				),
 			},
-			sigAlgo:  crypto.ECDSA_P256,
-			hashAlgo: crypto.SHA3_256,
+			sigAlgo: []crypto.SignatureAlgorithm{
+				tests.SigAlgos()[0],
+			},
+			hashAlgo: []crypto.HashAlgorithm{
+				tests.HashAlgos()[0],
+			},
 			pubKeys: []crypto.PublicKey{
 				tests.PubKeys()[0],
 			},
@@ -393,8 +407,8 @@ func TestAccountsCreate_Integration(t *testing.T) {
 			for x, k := range acc.Keys {
 				assert.Equal(t, k.PublicKey, a.pubKeys[x])
 				assert.Equal(t, k.Weight, c.weights[x])
-				assert.Equal(t, k.SigAlgo, a.sigAlgo)
-				assert.Equal(t, k.HashAlgo, a.hashAlgo)
+				assert.Equal(t, k.SigAlgo, a.sigAlgo[x])
+				assert.Equal(t, k.HashAlgo, a.hashAlgo[x])
 			}
 
 		}
@@ -418,35 +432,35 @@ func TestAccountsCreate_Integration(t *testing.T) {
 		accIn := []accountsIn{
 			{
 				account:  srvAcc,
-				sigAlgo:  crypto.ECDSA_P256,
-				hashAlgo: crypto.SHA3_256,
+				sigAlgo:  []crypto.SignatureAlgorithm{crypto.ECDSA_P256},
+				hashAlgo: []crypto.HashAlgorithm{crypto.SHA3_256},
 				args:     []string{"Invalid:Invalid"},
 				pubKeys: []crypto.PublicKey{
 					tests.PubKeys()[0],
 				},
 				weights: []int{1000},
 			}, {
 				account:  srvAcc,
-				sigAlgo:  crypto.UnknownSignatureAlgorithm,
-				hashAlgo: crypto.SHA3_256,
+				sigAlgo:  []crypto.SignatureAlgorithm{crypto.UnknownSignatureAlgorithm},
+				hashAlgo: []crypto.HashAlgorithm{crypto.SHA3_256},
 				args:     nil,
 				pubKeys: []crypto.PublicKey{
 					tests.PubKeys()[0],
 				},
 				weights: []int{1000},
 			}, {
 				account:  srvAcc,
-				sigAlgo:  crypto.UnknownSignatureAlgorithm,
-				hashAlgo: crypto.UnknownHashAlgorithm,
+				sigAlgo:  []crypto.SignatureAlgorithm{crypto.UnknownSignatureAlgorithm},
+				hashAlgo: []crypto.HashAlgorithm{crypto.UnknownHashAlgorithm},
 				args:     nil,
 				pubKeys: []crypto.PublicKey{
 					tests.PubKeys()[0],
 				},
 				weights: []int{1000},
 			}, {
 				account:  srvAcc,
-				sigAlgo:  crypto.ECDSA_P256,
-				hashAlgo: crypto.SHA3_256,
+				sigAlgo:  []crypto.SignatureAlgorithm{crypto.ECDSA_P256},
+				hashAlgo: []crypto.HashAlgorithm{crypto.SHA3_256},
 				args:     nil,
 				pubKeys: []crypto.PublicKey{
 					tests.PubKeys()[0],
@@ -455,8 +469,8 @@ func TestAccountsCreate_Integration(t *testing.T) {
 				weights: []int{1000},
 			}, {
 				account:  srvAcc,
-				sigAlgo:  crypto.ECDSA_P256,
-				hashAlgo: crypto.SHA3_256,
+				sigAlgo:  []crypto.SignatureAlgorithm{crypto.ECDSA_P256},
+				hashAlgo: []crypto.HashAlgorithm{crypto.SHA3_256},
 				args:     nil,
 				pubKeys: []crypto.PublicKey{
 					tests.PubKeys()[0],

pkg/flowkit/services/accounts_test.go

@@ -22,7 +22,6 @@ import (
 	"testing"
 
 	"github.com/onflow/flow-go-sdk"
-	"github.com/onflow/flow-go-sdk/crypto"
 	"github.com/stretchr/testify/assert"
 
 	"github.com/onflow/flow-cli/tests"
@@ -108,7 +107,7 @@ func TestBlocksGet_Integration(t *testing.T) {
 		assert.Equal(t, block.ID.String(), "7bc42fe85d32ca513769a74f97f7e1a7bad6c9407f0d934c2aa645ef9cf613c7")
 
 		// create an event
-		_, _ = s.Accounts.Create(srvAcc, tests.PubKeys(), nil, crypto.ECDSA_P256, crypto.SHA3_256, nil)
+		_, _ = s.Accounts.Create(srvAcc, tests.PubKeys(), nil, tests.SigAlgos(), tests.HashAlgos(), nil)
 
 		block, blockEvents, _, err = s.Blocks.GetBlock("latest", "flow.AccountCreated", true)