[NayNay] File Restructure: Accounts Restructure

CHANGELOG.md

@@ -34,6 +34,9 @@ Version header format: `[version] Name - year-month-day (entropy-core compatibil
 - new: './src/transfer' - new file structure for our CLI/TUI flows
   - new: './src/transfer/command.ts' - main entry file for transfer command for tui/cli
   - new: './src/transfer/utils.ts' - utilities and helper methods for all things transfer
+- new: './src/accounts' - new file structure for our CLI/TUI flows
+  - new: './src/accounts/command.ts' - main entry file for accounts command for tui/cli
+  - new: './src/accounts/utils.ts' - utilities and helper methods for all things accounts
 
 ### Changed
 
@@ -43,6 +46,8 @@ Version header format: `[version] Name - year-month-day (entropy-core compatibil
 - merged user + dev program folders + tests
 - removed flows/balance/*.ts directory with file restructure
 - removed flows/entropyTransfer/*.ts directory with file restructure
+- removed flows/manage-accounts/*/*.ts directory with file restructure
+- removed flows/register/*.ts directory with file restructure
 
 
 ### Broke

src/account/command.ts

@@ -0,0 +1,142 @@
+import Entropy from "@entropyxyz/sdk"
+import { Command, Option } from 'commander'
+import { EntropyAccount } from "./main";
+import { ACCOUNTS_CONTENT } from './constants'
+import * as config from '../config'
+import { cliWrite, currentAccountAddressOption, endpointOption, loadEntropy, passwordOption } from "../common/utils-cli";
+import { findAccountNameByAddress, updateConfig } from "src/common/utils";
+
+export function entropyAccountCommand () {
+  const accountCommand = new Command('account')
+    .description('Commands to work with accounts on the Entropy Network')
+    .addCommand(entropyAccountCreate())
+    .addCommand(entropyAccountImport())
+    .addCommand(entropyAccountList())
+    .addCommand(entropyAccountRegister())
+
+  return accountCommand
+}
+
+function entropyAccountCreate () {
+  const accountCreateCommand = new Command('create')
+    .alias('new')
+    .description('Create a new entropy account from scratch. Output is JSON of form {name, address}')
+    .addOption(passwordOption())
+    .argument('<name>', 'A user friendly name for your new account.')
+    .addOption(
+      new Option(
+        '--path',
+        'Derivation path'
+      ).default(ACCOUNTS_CONTENT.path.default)
+    )
+    .action(async (name, opts) => {
+      const { path } = opts
+      const newAccount = await EntropyAccount.create({ name, path })
+
+      await persistAndSelectNewAccount(newAccount)
+
+      cliWrite({
+        name: newAccount.name,
+        address: newAccount.address
+      })
+      process.exit(0)
+    })
+  return accountCreateCommand
+}
+
+function entropyAccountImport () {
+  const accountImportCommand = new Command('import')
+    .description('Import an existing entropy account from seed. Output is JSON of form {name, address}')
+    .addOption(passwordOption())
+    .argument('<name>', 'A user friendly name for your new account.')
+    .argument('<seed>', 'The seed for the account you are importing')
+    .addOption(
+      new Option(
+        '--path',
+        'Derivation path'
+      ).default(ACCOUNTS_CONTENT.path.default)
+    )
+    .action(async (name, seed, opts) => {
+      const { path } = opts
+      const newAccount = await EntropyAccount.import({ name, seed, path })
+
+      await persistAndSelectNewAccount(newAccount)
+
+      cliWrite({
+        name: newAccount.name,
+        address: newAccount.address
+      })
+      process.exit(0)
+    })
+  return accountImportCommand
+}
+
+async function persistAndSelectNewAccount (newAccount) {
+  const storedConfig = await config.get()
+  const { accounts } = storedConfig
+
+  const isExistingName = accounts.find(account => account.name === newAccount.name)
+  if (isExistingName) {
+    throw Error(`An account with name "${newAccount.name}" already exists. Choose a different name`)
+  }
+
+  accounts.push(newAccount) 
+  await updateConfig(storedConfig, {
+    accounts,
+    selectedAccount: newAccount.address
+  })
+}
+
+function entropyAccountList () {
+  const accountListCommand = new Command('list')
+    .alias('ls')
+    .description('List all accounts. Output is JSON of form [{ name, address, verifyingKeys }]')
+    .action(async () => {
+      // TODO: test if it's an encrypted account, if no password provided, throw because later on there's no protection from a prompt coming up
+      const storedConfig = await config.get()
+      const accounts = EntropyAccount.list(storedConfig)
+      cliWrite(accounts)
+      process.exit(0)
+    })
+  return accountListCommand
+}
+
+/* register */
+function entropyAccountRegister () {
+  const accountRegisterCommand = new Command('register')
+  accountRegisterCommand
+    .description('Register an entropy account with a program')
+    .addOption(passwordOption())
+    .addOption(endpointOption())
+    .addOption(currentAccountAddressOption())
+    // Removing these options for now until we update the design to accept program configs
+    // .addOption(
+    //   new Option(
+    //     '-pointer, --pointer',
+    //     'Program pointer of program to be used for registering'
+    //   )
+    // )
+    // .addOption(
+    //   new Option(
+    //     '-data, --program-data',
+    //     'Path to file containing program data in JSON format'
+    //   )
+    // )
+    .action(async (opts) => {
+      const storedConfig = await config.get()
+      const { accounts } = storedConfig
+      const entropy: Entropy = await loadEntropy(opts.account, opts.endpoint)
+      const AccountsService = new EntropyAccount(entropy, opts.endpoint)
+      const accountToRegister = findAccountNameByAddress(accounts, opts.account)
+      if (!accountToRegister) {
+        throw new Error('AccountError: Unable to register non-existent account')
+      }
+      const updatedAccount = await AccountsService.registerAccount(accountToRegister)
+      const arrIdx = accounts.indexOf(accountToRegister)
+      accounts.splice(arrIdx, 1, updatedAccount)
+      await updateConfig(storedConfig, { accounts, selectedAccount: updatedAccount.address })
+      cliWrite("Your address" + updatedAccount.address + "has been successfully registered.")
+      process.exit(0)
+    })
+  return accountRegisterCommand
+}

src/account/constants.ts

@@ -0,0 +1,36 @@
+export const FLOW_CONTEXT = 'ENTROPY_ACCOUNTS'
+
+export const ACCOUNTS_CONTENT = {
+  seed: {
+    name: 'seed',
+    message: 'Enter seed:',
+    invalidSeed: 'Seed provided is not valid'
+  },
+  path: {
+    name: 'path',
+    message: 'derivation path:',
+    default: 'none',
+  },
+  importKey: {
+    name: 'importKey',
+    message: 'Would you like to import your own seed?',
+    default: false
+  },
+  name: {
+    name: 'name',
+    default: 'My Key',
+  },
+  selectAccount: {
+    name: "selectedAccount",
+    message: "Choose account:",
+  },
+  interactionChoice: {
+    name: 'interactionChoice',
+    choices: [
+      { name: 'Create/Import Account', value: 'create-import' },
+      { name: 'Select Account', value: 'select-account' },
+      { name: 'List Accounts', value: 'list-account' },
+      { name: 'Exit to Main Menu', value: 'exit' }
+    ]
+  }
+}

src/account/interaction.ts

@@ -0,0 +1,89 @@
+import inquirer from "inquirer";
+import Entropy from "@entropyxyz/sdk";
+
+import { findAccountNameByAddress, print } from "../common/utils"
+import { EntropyConfig } from "../config/types";
+import { EntropyAccount } from './main'
+
+import { 
+  manageAccountsQuestions,
+  newAccountQuestions,
+  selectAccountQuestions
+} from "./utils"
+
+
+export async function entropyManageAccounts (endpoint: string, storedConfig: EntropyConfig) {
+  const { accounts } = storedConfig
+  const { interactionChoice } = await inquirer.prompt(manageAccountsQuestions)
+
+  switch (interactionChoice) {
+
+  case 'create-import': {
+    const answers = await inquirer.prompt(newAccountQuestions)
+    const { name, path, importKey } = answers
+    let { seed } = answers
+    if (importKey && seed.includes('#debug')) {
+      // isDebugMode = true
+      seed = seed.split('#debug')[0]
+    }
+    const newAccount = seed
+      ? await EntropyAccount.import({ seed, name, path })
+      : await EntropyAccount.create({ name, path })
+    accounts.push(newAccount) 
+
+    return {
+      accounts,
+      selectedAccount: newAccount.address
+    }
+  }
+
+  case 'select-account': {
+    if (!accounts.length) {
+      console.error('There are currently no accounts available, please create or import a new account using the Manage Accounts feature')
+      return
+    }
+    const { selectedAccount } = await inquirer.prompt(selectAccountQuestions(accounts))
+    print('Current selected account is ' + selectedAccount)
+
+    return {
+      accounts: storedConfig.accounts,
+      selectedAccount: selectedAccount.address
+    }
+  }
+
+  case 'list-account': {
+    try {
+      EntropyAccount.list({ accounts })
+        .forEach((account) => print(account))
+    } catch (error) {
+      console.error(error.message.split('AccountsError: ')[1])
+    }
+    return
+  }
+
+  case 'exit': {
+    return 'exit'
+  }
+
+  default:
+    throw new Error('AccountsError: Unknown interaction action')
+  }
+}
+
+export async function entropyRegister (entropy: Entropy, endpoint: string, storedConfig: EntropyConfig): Promise<Partial<EntropyConfig>> {
+  const AccountService = new EntropyAccount(entropy, endpoint)
+
+  const { accounts, selectedAccount } = storedConfig
+  const currentAccount = findAccountNameByAddress(accounts, selectedAccount)
+  if (!currentAccount) {
+    print("No account selected to register")
+    return;
+  }
+  print("Attempting to register the address:", currentAccount.address)
+  const updatedAccount = await AccountService.registerAccount(currentAccount)
+  const arrIdx = accounts.indexOf(currentAccount)
+  accounts.splice(arrIdx, 1, updatedAccount)
+  print("Your address", updatedAccount.address, "has been successfully registered.")
+
+  return { accounts, selectedAccount }
+}