QA file-restructure

package.json

@@ -50,7 +50,6 @@
     "commander": "^12.0.0",
     "env-paths": "^3.0.0",
     "inquirer": "8.0.0",
-    "lodash.clonedeep": "^4.5.0",
     "mkdirp": "^3.0.1",
     "winston": "^3.13.0",
     "x25519": "^0.1.0"

src/account/command.ts

@@ -13,6 +13,9 @@ export function entropyAccountCommand () {
     .addCommand(entropyAccountImport())
     .addCommand(entropyAccountList())
     .addCommand(entropyAccountRegister())
+    // .addCommand(entropyAccountAlias())
+    // IDEA: support aliases for remote accounts (those we don't have seeds for)
+    // this would make transfers safer/ easier from CLI
 }
 
 function entropyAccountCreate () {
@@ -35,7 +38,8 @@ function entropyAccountCreate () {
 
       cliWrite({
         name: newAccount.name,
-        address: newAccount.address
+        address: newAccount.address,
+        verifyingKeys: []
       })
       process.exit(0)
     })
@@ -61,7 +65,8 @@ function entropyAccountImport () {
 
       cliWrite({
         name: newAccount.name,
-        address: newAccount.address
+        address: newAccount.address,
+        verifyingKeys: []
       })
       process.exit(0)
     })
@@ -73,8 +78,14 @@ function entropyAccountList () {
     .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)
+      const accounts = await config.get()
+        .then(storedConfig => EntropyAccount.list(storedConfig))
+        .catch((err) => {
+          if (err.message.includes('currently no accounts')) return []
+
+          throw err
+        })
+
       cliWrite(accounts)
       process.exit(0)
     })
@@ -84,9 +95,9 @@ function entropyAccountList () {
 function entropyAccountRegister () {
   return new Command('register')
     .description('Register an entropy account with a program')
-    .addOption(passwordOption())
-    .addOption(endpointOption())
     .addOption(accountOption())
+    .addOption(endpointOption())
+    .addOption(passwordOption())
     // Removing these options for now until we update the design to accept program configs
     // .addOption(
     //   new Option(

src/account/interaction.ts

@@ -45,10 +45,7 @@ export async function entropyAccount (endpoint: string, storedConfig: EntropyCon
       return
     }
     const { selectedAccount } = await inquirer.prompt(accountSelectQuestions(accounts))
-    await config.set({
-      ...storedConfig,
-      selectedAccount: selectedAccount.address
-    })
+    await config.setSelectedAccount(selectedAccount)
 
     print('Current selected account is ' + selectedAccount)
     return

src/account/main.ts

@@ -7,7 +7,7 @@ import { FLOW_CONTEXT } from "./constants";
 import { AccountCreateParams, AccountImportParams, AccountRegisterParams } from "./types";
 
 import { EntropyBase } from "../common/entropy-base";
-import { EntropyAccountConfig } from "../config/types";
+import { EntropyAccountConfig, EntropyAccountConfigFormatted } from "../config/types";
 
 export class EntropyAccount extends EntropyBase {
   constructor (entropy: Entropy, endpoint: string) {
@@ -19,28 +19,28 @@ export class EntropyAccount extends EntropyBase {
     return EntropyAccount.import({ name, seed, path })
   }
 
+  // WARNING: #create depends on #import => be careful modifying this function
   static async import ({ name, seed, path }: AccountImportParams ): Promise<EntropyAccountConfig> {
-    // WARNING: #create currently depends on this => be careful modifying this function
-
     await wasmGlobalsReady()
     const keyring = new Keyring({ seed, path, debug: true })
+
     const fullAccount = keyring.getAccount()
     // TODO: sdk should create account on constructor
-    const { admin } = keyring.getAccount()
+    const data = fixData(fullAccount)
+    const maybeEncryptedData = data
+    // const maybeEncryptedData = password ? passwordFlow.encrypt(data, password) : data
 
-    const data = fullAccount
+    const { admin } = keyring.getAccount()
     delete admin.pair
-    // const encryptedData = password ? passwordFlow.encrypt(data, password) : data
-
+
     return {
       name,
       address: admin.address,
-      data
-      // data: encryptedData // TODO: replace once password input is added back
+      data: maybeEncryptedData,
     }
   }
 
-  static list ({ accounts }: { accounts: EntropyAccountConfig[] }) {
+  static list ({ accounts }: { accounts: EntropyAccountConfig[] }): EntropyAccountConfigFormatted[] {
     if (!accounts.length)
       throw new Error(
         'AccountsError: There are currently no accounts available, please create or import a new account using the Manage Accounts feature'
@@ -49,7 +49,7 @@ export class EntropyAccount extends EntropyBase {
     return accounts.map((account: EntropyAccountConfig) => ({
       name: account.name,
       address: account.address,
-      verifyingKeys: account?.data?.admin?.verifyingKeys
+      verifyingKeys: account?.data?.registration?.verifyingKeys || []
     }))
   }
 
@@ -90,7 +90,7 @@ export class EntropyAccount extends EntropyBase {
                 dispatchError.asModule
               )
               const { docs, name, section } = decoded
-  
+
               msg = `${section}.${name}: ${docs.join(' ')}`
             } else {
               // Other, CannotLookup, BadOrigin, no extra info
@@ -107,3 +107,28 @@ export class EntropyAccount extends EntropyBase {
     })
   }
 }
+
+// TODO: there is a bug in SDK that is munting this data
+function fixData (data) {
+  if (data.admin) {
+    data.admin.pair.addressRaw = objToUint8Array(data.admin.pair.addressRaw)
+    data.admin.pair.secretKey = objToUint8Array(data.admin.pair.secretKey)
+    data.admin.pair.publicKey = objToUint8Array(data.admin.pair.publicKey)
+  }
+
+  if (data.registration) {
+    data.registration.pair.addressRaw = objToUint8Array(data.registration.pair.addressRaw)
+    data.registration.pair.secretKey = objToUint8Array(data.registration.pair.secretKey)
+    data.registration.pair.publicKey = objToUint8Array(data.registration.pair.publicKey)
+  }
+
+  return data
+}
+
+function objToUint8Array (obj) {
+  const values: any = Object.entries(obj)
+    .sort((a, b) => Number(a[0]) - Number(b[0])) // sort entries by keys
+    .map(entry => entry[1])
+
+  return new Uint8Array(values)
+}

src/account/utils.ts

@@ -19,21 +19,23 @@ export async function selectAndPersistNewAccount (newAccount: EntropyAccountConf
   accounts.push(newAccount) 
   await config.set({
     ...storedConfig,
-    selectedAccount: newAccount.address
+    selectedAccount: newAccount.name
   })
 }
 
 export async function addVerifyingKeyToAccountAndSelect (verifyingKey: string, accountNameOrAddress: string) {
   const storedConfig = await config.get()
-  const account = findAccountByAddressOrName(storedConfig.accounts, accountNameOrAddress)
+  const { accounts } = storedConfig
+
+  const account = findAccountByAddressOrName(accounts, accountNameOrAddress)
   if (!account) throw Error(`Unable to persist verifyingKey "${verifyingKey}" to unknown account "${accountNameOrAddress}"`)
 
   account.data.registration.verifyingKeys.push(verifyingKey)
 
   // persist to config, set selectedAccount
   await config.set({
     ...storedConfig,
-    selectedAccount: account.address
+    setSelectedAccount: account.name
   })
 }
 

src/balance/command.ts

@@ -1,22 +1,29 @@
 import { Command } from "commander";
 import Entropy from "@entropyxyz/sdk";
-import { cliWrite, endpointOption, loadEntropy, passwordOption } from "src/common/utils-cli";
+
 import { EntropyBalance } from "./main";
+import { cliWrite, endpointOption, loadEntropy, passwordOption } from "../common/utils-cli";
+import { findAccountByAddressOrName } from "../common/utils";
+import * as config from "../config";
 
 export function entropyBalanceCommand () {
   const balanceCommand = new Command('balance')
   balanceCommand
     .description('Command to retrieive the balance of an account on the Entropy Network')
-    .argument('address', 'Account address whose balance you want to query')
-    .addOption(passwordOption())
+    .argument('account <address|name>', 'Account address whose balance you want to query')
     .addOption(endpointOption())
-    .action(async (address, opts) => {
-      const entropy: Entropy = await loadEntropy(address, opts.endpoint)
+    .addOption(passwordOption())
+    .action(async (account, opts) => {
+      const entropy: Entropy = await loadEntropy(account, opts.endpoint)
       const BalanceService = new EntropyBalance(entropy, opts.endpoint)
+
+      const { accounts } = await config.get()
+      const address = findAccountByAddressOrName(accounts, account)?.address
+
       const balance = await BalanceService.getBalance(address)
       cliWrite(`${balance.toLocaleString('en-US')} BITS`)
       process.exit(0)
     })
-  
+
   return balanceCommand
 }

src/common/masking.ts

@@ -1,37 +1,38 @@
-import cloneDeep from 'lodash.clonedeep'
-
-const DEFAULT_MASKED_FIELDS = [
+const PREFIX = 'data:application/UI8A;base64,'
+const DEFAULT_MASKED_FIELDS = new Set([
   'seed',
   'secretKey',
   'addressRaw',
-];
+]);
 
 export function maskPayload (payload: any): any {
-  if (typeof payload === 'string') return payload
-
-  const clonedPayload = cloneDeep(payload);
-  const maskedPayload = {}
+  if (
+    typeof payload === 'string' ||
+    typeof payload === 'boolean' ||
+    payload === null
+  ) return payload
 
-  if (!clonedPayload) {
-    return clonedPayload;
-  }
+  const maskedPayload = Array.isArray(payload)
+    ? []
+    : {}
 
   // maskJSONFields doesn't handle nested objects very well so we'll
   // need to recursively walk to object and mask them one by one
-  for (const [property, value] of Object.entries(clonedPayload)) {
-    if (value && typeof value === 'object') {
-      if (Object.keys(clonedPayload[property]).filter(key => isNaN(parseInt(key))).length === 0) {
-        const reconstructedUintArr: number[] = Object.values(clonedPayload[property])
-        maskedPayload[property] = "base64:" + Buffer.from(reconstructedUintArr).toString("base64");
-      } else {
-        maskedPayload[property] = maskPayload(value);
-      }
-    } else if (value && typeof value === 'string' && DEFAULT_MASKED_FIELDS.includes(property)) {
-      maskedPayload[property] = "*".repeat(clonedPayload[property].length)
-    } else {
-      maskedPayload[property] = value
+  return Object.entries(payload).reduce((acc, [property, value]) => {
+    if (DEFAULT_MASKED_FIELDS.has(property)) {
+      // @ts-expect-error .length does not exist on type "unknown"
+      acc[property] = "*".repeat(value?.length || 32)
+    }
+    else if (value instanceof Uint8Array) {
+      acc[property] = PREFIX + Buffer.from(value).toString('base64')
+    }
+    else if (typeof value === 'object') {
+      acc[property] = maskPayload(value);
+    }
+    else {
+      acc[property] = value
     }
-  }
 
-  return maskedPayload;
+    return acc
+  }, maskedPayload)
 }

src/common/utils-cli.ts

@@ -20,7 +20,7 @@ function getConfigOrNull () {
 
 export function endpointOption () {
   return new Option(
-    '-e, --endpoint <endpoint>',
+    '-e, --endpoint <url>',
     [
       'Runs entropy with the given endpoint and ignores network endpoints in config.',
       'Can also be given a stored endpoint name from config eg: `entropy --endpoint test-net`.'
@@ -39,41 +39,48 @@ export function endpointOption () {
       return endpoint
     })
     .default('ws://testnet.entropy.xyz:9944/')
-    // NOTE: argParser is only run IF an option is provided, so this cannot be 'test-net'
+    // NOTE: argParser only runs IF the -e/--endpoint option called, so this default cannot be 'test-net'
 }
 
 export function passwordOption (description?: string) {
   return new Option(
-    '-p, --password <password>',
+    '-p, --password',
     description || 'Password for the account'
   )
+    .hideHelp() // TEMP
 }
 
 export function accountOption () {
   const storedConfig = getConfigOrNull()
 
   return new Option(
-    '-a, --account <accountAddressOrName>',
+    '-a, --account <address|name>',
     [
       'Sets the account for the session.',
       'Defaults to the last set account (or the first account if one has not been set before).'
     ].join(' ')
   )
     .env('ENTROPY_ACCOUNT')
-    .argParser(async (account) => {
-      if (storedConfig && storedConfig.selectedAccount !== account) {
-        // Updated selected account in config with new address from this option
-        await config.set({
-          ...storedConfig,
-          selectedAccount: account
-        })
-      }
+    .argParser(addressOrName => {
+      // We try to map addressOrName to an account we have stored
+      if (!storedConfig) return addressOrName
 
-      return account
+      const account = findAccountByAddressOrName(storedConfig.accounts, addressOrName)
+      if (!account) return addressOrName
+
+      // If we find one, we set this account as the future default
+      config.setSelectedAccount(account)
+      // NOTE: argParser cannot be an async function, so we cannot await this call
+      // WARNING: this will lead to a race-condition if functions are called in quick succession
+      // and assume the selectedAccount has been persisted
+      //
+      // RISK: doesn't seem likely as most of our functions will await at slow other steps....
+      // SOLUTION: write a scynchronous version?
+
+      // We finally return the account name to be as consistent as possible (using name, not address)
+      return account.name
     })
     .default(storedConfig?.selectedAccount)
-    // TODO: display the *name* not address
-    // TODO: standardise whether selectedAccount is name or address.
 }
 
 export async function loadEntropy (addressOrName: string, endpoint: string, password?: string): Promise<Entropy> {

src/config/encoding.ts

@@ -1,12 +1,17 @@
 const PREFIX = 'data:application/UI8A;base64,'
 // was a UInt8Array, but is stored as base64
 
-export function serialize (config) {
+export function serialize (config: object) {
   return JSON.stringify(config, replacer, 2)
 }
 
-export function deserialize (config) {
-  return JSON.parse(config, reviver)
+export function deserialize (config: string) {
+  try {
+    return JSON.parse(config, reviver)
+  } catch (err) {
+    console.log('broken config:', config)
+    throw err
+  }
 }
 
 function replacer (_key: string, value: any) {