Merge pull request #2054 from onflow/cf/acct-name-funding

Allow `fund` command to accept account names from `flow.json`

Author: chasefleming

internal/accounts/fund.go

@@ -56,11 +56,36 @@ func getTestnetAccounts(state *flowkit.State) []accounts.Account {
 	return testnetAccounts
 }
 
+// resolveAddressOrAccountName resolves a string that could be either an address or account name
+func resolveAddressOrAccountName(input string, state *flowkit.State) (flowsdk.Address, error) {
+	address := flowsdk.HexToAddress(input)
+
+	if address.IsValid(flowsdk.Mainnet) || address.IsValid(flowsdk.Testnet) || address.IsValid(flowsdk.Emulator) {
+		// For direct addresses, we'll let the caller handle testnet validation
+		return address, nil
+	}
+
+	account, err := state.Accounts().ByName(input)
+	if err != nil {
+		accountName := branding.GrayStyle.Render(input)
+		return flowsdk.EmptyAddress, fmt.Errorf("could not find account with name %s", accountName)
+	}
+
+	if !account.Address.IsValid(flowsdk.Testnet) {
+		accountName := branding.PurpleStyle.Render(input)
+		addressStr := branding.GrayStyle.Render(account.Address.String())
+		errorMsg := branding.ErrorStyle.Render("The faucet can only fund testnet addresses")
+		return flowsdk.EmptyAddress, fmt.Errorf("account %s has address %s which is not valid for testnet. %s", accountName, addressStr, errorMsg)
+	}
+
+	return account.Address, nil
+}
+
 var fundCommand = &command.Command{
 	Cmd: &cobra.Command{
-		Use:     "fund [address]",
-		Short:   "Funds an account by address through the Testnet Faucet",
-		Example: "flow accounts fund 8e94eaa81771313a\nflow accounts fund",
+		Use:     "fund [address|name]",
+		Short:   "Funds an account by address or account name through the Testnet Faucet",
+		Example: "flow accounts fund 8e94eaa81771313a\nflow accounts fund testnet-account\nflow accounts fund",
 		Args:    cobra.MaximumNArgs(1),
 	},
 	Flags: &fundFlags,
@@ -88,12 +113,13 @@ func fund(
 
 		options := make([]string, len(testnetAccounts))
 		for i, account := range testnetAccounts {
-			options[i] = fmt.Sprintf("0x%s (%s)", account.Address.String(), account.Name)
+			options[i] = fmt.Sprintf("%s (%s)", account.Address.HexWithPrefix(), account.Name)
 		}
 
 		selected, err := prompt.RunSingleSelect(options, "Select a testnet account to fund:")
 		if err != nil {
-			return nil, fmt.Errorf("account selection cancelled: %w", err)
+			errorMsg := branding.ErrorStyle.Render("account selection cancelled")
+			return nil, fmt.Errorf("%s: %w", errorMsg, err)
 		}
 
 		for i, option := range options {
@@ -103,19 +129,28 @@ func fund(
 			}
 		}
 	} else {
-		address = flowsdk.HexToAddress(args[0])
+		var err error
+		address, err = resolveAddressOrAccountName(args[0], state)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	if !address.IsValid(flowsdk.Testnet) {
-		return nil, fmt.Errorf("unsupported address %s, faucet can only work for valid Testnet addresses", address.String())
+		addressStr := branding.GrayStyle.Render(address.String())
+		errorMsg := branding.ErrorStyle.Render("faucet can only work for valid Testnet addresses")
+		return nil, fmt.Errorf("unsupported address %s, %s", addressStr, errorMsg)
 	}
 
+	addressStr := branding.PurpleStyle.Render(address.HexWithPrefix())
+	linkStr := branding.GreenStyle.Render(testnetFaucetURL(address))
+
 	logger.Info(
 		fmt.Sprintf(
-			"Opening the Testnet faucet to fund 0x%s on your native browser."+
+			"Opening the Testnet faucet to fund %s on your native browser."+
 				"\n\nIf there is an issue, please use this link instead: %s",
-			address.String(),
-			testnetFaucetURL(address),
+			addressStr,
+			linkStr,
 		))
 	// wait for the user to read the message
 	time.Sleep(5 * time.Second)

internal/accounts/fund_test.go

@@ -24,6 +24,7 @@ import (
 	"github.com/onflow/flow-go-sdk"
 	"github.com/onflow/flow-go-sdk/crypto"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"github.com/onflow/flowkit/v2/accounts"
 
@@ -111,6 +112,80 @@ func Test_GetTestnetAccounts(t *testing.T) {
 	})
 }
 
+func Test_ResolveAddressOrAccountName(t *testing.T) {
+	t.Run("Resolves valid hex address", func(t *testing.T) {
+		_, state, _ := util.TestMocks(t)
+
+		address, err := resolveAddressOrAccountName("8efde57e98c557fa", state)
+
+		require.NoError(t, err)
+		assert.Equal(t, "8efde57e98c557fa", address.String())
+	})
+
+	t.Run("Resolves address with 0x prefix", func(t *testing.T) {
+		_, state, _ := util.TestMocks(t)
+
+		address, err := resolveAddressOrAccountName("0x8efde57e98c557fa", state)
+
+		require.NoError(t, err)
+		assert.Equal(t, "8efde57e98c557fa", address.String())
+	})
+
+	t.Run("Resolves account name", func(t *testing.T) {
+		_, state, _ := util.TestMocks(t)
+
+		// Add a testnet account to state
+		testnetAddr := flow.HexToAddress("8efde57e98c557fa")
+		testnetAccount := &accounts.Account{
+			Name:    "my-testnet-account",
+			Address: testnetAddr,
+			Key:     accounts.NewHexKeyFromPrivateKey(0, crypto.SHA3_256, generateTestPrivateKey()),
+		}
+		state.Accounts().AddOrUpdate(testnetAccount)
+
+		address, err := resolveAddressOrAccountName("my-testnet-account", state)
+
+		require.NoError(t, err)
+		assert.Equal(t, testnetAddr, address)
+	})
+
+	t.Run("Fails with invalid account name", func(t *testing.T) {
+		_, state, _ := util.TestMocks(t)
+
+		address, err := resolveAddressOrAccountName("non-existent-account", state)
+
+		assert.Equal(t, flow.EmptyAddress, address)
+		assert.Error(t, err)
+	})
+
+	t.Run("Fails with invalid hex string", func(t *testing.T) {
+		_, state, _ := util.TestMocks(t)
+
+		address, err := resolveAddressOrAccountName("invalid-hex-123", state)
+
+		assert.Equal(t, flow.EmptyAddress, address)
+		assert.Error(t, err)
+	})
+
+	t.Run("Fails when account name resolves to non-testnet address", func(t *testing.T) {
+		_, state, _ := util.TestMocks(t)
+
+		// Add an emulator account (not testnet-valid)
+		emulatorAddr := flow.HexToAddress("f8d6e0586b0a20c7")
+		emulatorAccount := &accounts.Account{
+			Name:    "emulator-account",
+			Address: emulatorAddr,
+			Key:     accounts.NewHexKeyFromPrivateKey(0, crypto.SHA3_256, generateTestPrivateKey()),
+		}
+		state.Accounts().AddOrUpdate(emulatorAccount)
+
+		address, err := resolveAddressOrAccountName("emulator-account", state)
+
+		assert.Equal(t, flow.EmptyAddress, address)
+		assert.Error(t, err)
+	})
+}
+
 func Test_Fund(t *testing.T) {
 	srv, state, _ := util.TestMocks(t)
 
@@ -126,7 +201,31 @@ func Test_Fund(t *testing.T) {
 		)
 
 		assert.Nil(t, result)
-		assert.Contains(t, err.Error(), "faucet can only work for valid Testnet addresses")
+		assert.Error(t, err)
+	})
+
+	t.Run("Fail with non-testnet account name", func(t *testing.T) {
+		// Add an emulator account to the state
+		emulatorAddr := flow.HexToAddress("f8d6e0586b0a20c7")
+		emulatorAccount := &accounts.Account{
+			Name:    "emulator-account",
+			Address: emulatorAddr,
+			Key:     accounts.NewHexKeyFromPrivateKey(0, crypto.SHA3_256, generateTestPrivateKey()),
+		}
+		state.Accounts().AddOrUpdate(emulatorAccount)
+
+		args := []string{"emulator-account"} // Non-testnet account name
+
+		result, err := fund(
+			args,
+			command.GlobalFlags{},
+			util.NoLogger,
+			srv.Mock,
+			state,
+		)
+
+		assert.Nil(t, result)
+		assert.Error(t, err)
 	})
 
 	t.Run("Fail with no address and no testnet accounts", func(t *testing.T) {
@@ -155,7 +254,7 @@ func Test_Fund(t *testing.T) {
 		)
 
 		assert.Nil(t, result)
-		assert.Contains(t, err.Error(), "no testnet accounts found in flow.json")
+		assert.Error(t, err)
 	})
 }