You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: eth_keys_commands.go
    path of file: ./repos/chainlink/core/cmd
    
    the code of the file until where you have to start completion: package cmd

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"os"
	"strings"

	"github.com/pkg/errors"
	"github.com/urfave/cli"
	"go.uber.org/multierr"

	cutils "github.com/smartcontractkit/chainlink-common/pkg/utils"
	"github.com/smartcontractkit/chainlink/v2/core/store/models"
	"github.com/smartcontractkit/chainlink/v2/core/utils"
	"github.com/smartcontractkit/chainlink/v2/core/web/presenters"
)

func initEthKeysSubCmd(s *Shell) cli.Command {
	return cli.Command{
		Name:  "eth",
		Usage: "Remote commands for administering the node's Ethereum keys",
		Subcommands: cli.Commands{
			{
				Name:   "create",
				Usage:  "Create a key in the node's keystore alongside the existing key; to create an original key, just run the node",
				Action: s.CreateETHKey,
				Flags: []cli.Flag{
					cli.StringFlag{
						Name:  "evm-chain-id, evmChainID",
						Usage: "Chain ID for the key. If left blank, default chain will be used.",
					},
					cli.Uint64Flag{
						Name:  "max-gas-price-gwei, maxGasPriceGWei",
						Usage: "Optional maximum gas price (GWei) for the creating key.",
					},
				},
			},
			{
				Name:   "list",
				Usage:  "List available Ethere
    
func (s *Shell) ExportETHKey(c *cli.Context) (err error) {
	if !c.Args().Present() {
		return s.errorOut(errors.New("Must pass the address of the key to export"))
	}

	newPasswordFile := c.String("new-password")
	if len(newPasswordFile) == 0 {
		return s.errorOut(errors.New("Must specify --new-password/-p flag"))
	}
	newPassword, err := os.ReadFile(newPasswordFile)
	if err != nil {
		return s.errorOut(errors.Wrap(err, "Could not read password file"))
	}

	filepath := c.String("output")
	if len(newPassword) == 0 {
		return s.errorOut(errors.New("Must specify --output/-o flag"))
	}

	address := c.Args().Get(0)
	exportUrl := url.URL{
		Path: "/v2/keys/evm/export/" + address,
	}
	query := exportUrl.Query()
	query.Set("newpassword", strings.TrimSpace(string(newPassword)))

	exportUrl.RawQuery = query.Encode()
	resp, err := s.HTTP.Post(s.ctx(), exportUrl.String(), nil)
	if err != nil {
		return s.errorOut(errors.Wrap(err, "Could not make HTTP request"))
	}
	defer func() {
		if cerr := resp.Body.Close(); cerr != nil {
			err = multierr.Append(err, cerr)
		}
	}()

	if resp.StatusCode != http.StatusOK {
		return s.errorOut(fmt.Errorf("error exporting: %w", httpError(resp)))
	}

	keyJSON, err := io.ReadAll(resp.Body)
	if err != nil {
		return s.errorOut(errors.Wrap(err, "Could not read response body"))
	}

	err = utils.WriteFileWithMaxPerms(filepath, keyJSON, 0o600)
	if err != nil {
		return s.errorOut(errors.Wrapf(err, "Could not write %v", filepath))
	}

	_, err = os.Stderr.WriteString("ðŸ”‘ Exported ETH key " + address + " to " + filepath + "\n")
	if err != nil {
		return s.errorOut(err)
	}

	return nil
}