accounts

var AddContractCommand = &command.Command{
	Cmd: &cobra.Command{
		Use:     "add-contract <name> <filename>",
		Short:   "Deploy a new contract to an account",
		Example: `flow accounts add-contract FungibleToken ./FungibleToken.cdc`,
		Args:    cobra.ExactArgs(2),
	},
	Flags: &addContractFlags,
	Run: func(
		cmd *cobra.Command,
		args []string,
		globalFlags command.GlobalFlags,
		services *services.Services,
	) (command.Result, error) {
		if createFlags.Results {
			fmt.Println("⚠️ DEPRECATION WARNING: results flag is deprecated, results are by default included in all executions")
		}

		account, err := services.Accounts.AddContract(
			addContractFlags.Signer,
			args[0],
			args[1],
			false,
		)

		if err != nil {
			return nil, err
		}

		return &AccountResult{
			Account:  account,
			showCode: false,
			include:  addContractFlags.Include,
		}, nil
	},
}

var Cmd = &cobra.Command{
	Use:              "accounts",
	Short:            "Utilities to manage accounts",
	TraverseChildren: true,
}

var CreateCommand = &command.Command{
	Cmd: &cobra.Command{
		Use:     "create",
		Short:   "Create a new account on network",
		Example: `flow accounts create --key d651f1931a2...8745`,
	},
	Flags: &createFlags,
	Run: func(
		cmd *cobra.Command,
		args []string,
		globalFlags command.GlobalFlags,
		services *services.Services,
	) (command.Result, error) {
		if createFlags.Results {
			fmt.Println("⚠️ DEPRECATION WARNING: results flag is deprecated, results are by default included in all executions")
		}

		account, err := services.Accounts.Create(
			createFlags.Signer,
			createFlags.Keys,
			createFlags.Weights,
			createFlags.SigAlgo,
			createFlags.HashAlgo,
			createFlags.Contracts,
		)

		if err != nil {
			return nil, err
		}

		return &AccountResult{
			Account: account,
			include: createFlags.Include,
		}, nil
	},
}

var GetCommand = &command.Command{
	Cmd: &cobra.Command{
		Use:     "get <address>",
		Short:   "Gets an account by address",
		Example: "flow accounts get f8d6e0586b0a20c7",
		Args:    cobra.ExactArgs(1),
	},
	Flags: &getFlags,
	Run: func(
		cmd *cobra.Command,
		args []string,
		globalFlags command.GlobalFlags,
		services *services.Services,
	) (command.Result, error) {
		if getFlags.Code {
			fmt.Println("⚠️  DEPRECATION WARNING: use contracts flag instead")
		}

		if getFlags.Contracts {
			fmt.Println("⚠️  DEPRECATION WARNING: use include contracts flag instead")
		}

		account, err := services.Accounts.Get(args[0])
		if err != nil {
			return nil, err
		}

		return &AccountResult{
			Account:  account,
			showCode: getFlags.Contracts || getFlags.Code,
			include:  getFlags.Include,
		}, nil
	},
}

var RemoveCommand = &command.Command{
	Cmd: &cobra.Command{
		Use:     "remove-contract <name>",
		Short:   "Remove a contract deployed to an account",
		Example: `flow accounts remove-contract FungibleToken`,
		Args:    cobra.ExactArgs(1),
	},
	Flags: &flagsRemove,
	Run: func(
		cmd *cobra.Command,
		args []string,
		globalFlags command.GlobalFlags,
		services *services.Services,
	) (command.Result, error) {
		if flagsRemove.Results {
			fmt.Println("⚠️ DEPRECATION WARNING: results flag is deprecated, results are by default included in all executions")
		}

		account, err := services.Accounts.RemoveContract(
			args[0],
			flagsRemove.Signer,
		)
		if err != nil {
			return nil, err
		}

		return &AccountResult{
			Account:  account,
			showCode: false,
			include:  flagsRemove.Include,
		}, nil
	},
}

var StakingCommand = &command.Command{
	Cmd: &cobra.Command{
		Use:     "staking-info <address>",
		Short:   "Get account staking info",
		Example: "flow accounts staking-info f8d6e0586b0a20c7",
		Args:    cobra.ExactArgs(1),
	},
	Flags: &stakingFlags,
	Run: func(
		cmd *cobra.Command,
		args []string,
		globalFlags command.GlobalFlags,
		services *services.Services,
	) (command.Result, error) {
		staking, delegation, err := services.Accounts.StakingInfo(args[0])
		if err != nil {
			return nil, err
		}

		return &StakingResult{*staking, *delegation}, nil
	},
}

var UpdateCommand = &command.Command{
	Cmd: &cobra.Command{
		Use:     "update-contract <name> <filename>",
		Short:   "Update a contract deployed to an account",
		Example: `flow accounts update-contract FungibleToken ./FungibleToken.cdc`,
		Args:    cobra.ExactArgs(2),
	},
	Flags: &updateFlags,
	Run: func(
		cmd *cobra.Command,
		args []string,
		globalFlags command.GlobalFlags,
		services *services.Services,
	) (command.Result, error) {
		if updateFlags.Results {
			fmt.Println("⚠️ DEPRECATION WARNING: results flag is deprecated, results are by default included in all executions")
		}

		account, err := services.Accounts.AddContract(
			updateFlags.Signer,
			args[0],
			args[1],
			true,
		)
		if err != nil {
			return nil, err
		}

		return &AccountResult{
			Account:  account,
			showCode: false,
			include:  updateFlags.Include,
		}, nil
	},
}