Improved config feature

src/commands/account/create.ts

@@ -1,21 +1,35 @@
 import { Flags } from "@oclif/core";
 import chalk from "chalk";
-import { ChainAccount, encrypt } from "../../lib/index.js";
+import { ChainAccount, encrypt, getSwankyConfig, isLocalConfigCheck } from "../../lib/index.js";
 import { AccountData } from "../../types/index.js";
 import inquirer from "inquirer";
 import { SwankyCommand } from "../../lib/swankyCommand.js";
+import { FileError } from "../../lib/errors.js";
+import { ConfigBuilder } from "../../lib/config-builder.js";
 export class CreateAccount extends SwankyCommand<typeof CreateAccount> {
   static description = "Create a new dev account in config";
 
   static flags = {
-    generate: Flags.boolean({
+    global: Flags.boolean({
       char: "g",
+      description: "Create account globally stored in Swanky system config.",
+
+    }),
+    new: Flags.boolean({
+      char: "n",
+      description: "Generate a brand new account.",
     }),
     dev: Flags.boolean({
       char: "d",
+      description: "Make this account a dev account for local network usage.",
     }),
   };
 
+  constructor(argv: string[], baseConfig: any) {
+    super(argv, baseConfig);
+    (this.constructor as typeof SwankyCommand).ENSURE_SWANKY_CONFIG = false;
+  }
+
   async run(): Promise<void> {
     const { flags } = await this.parse(CreateAccount);
 
@@ -36,7 +50,7 @@ export class CreateAccount extends SwankyCommand<typeof CreateAccount> {
     }
 
     let tmpMnemonic = "";
-    if (flags.generate) {
+    if (flags.new) {
       tmpMnemonic = ChainAccount.generate();
       console.log(
         `${
@@ -75,9 +89,23 @@ export class CreateAccount extends SwankyCommand<typeof CreateAccount> {
       accountData.mnemonic = tmpMnemonic;
     }
 
-    this.swankyConfig.accounts.push(accountData);
+    const configType = flags.global ? "global" : isLocalConfigCheck() ? "local" : "global";
+    const config = configType === "global" ? getSwankyConfig("global") : this.swankyConfig;
+
+    const configBuilder = new ConfigBuilder(config);
+    configBuilder.addAccount(accountData);
 
-    await this.storeConfig();
+    if (this.swankyConfig.defaultAccount === null) {
+      configBuilder.setDefaultAccount(accountData.alias);
+    }
+
+    try {
+      await this.storeConfig(configBuilder.build(), configType);
+    } catch (cause) {
+      throw new FileError(`Error storing created account in ${configType} config`, {
+        cause,
+      });
+    }
 
     this.log(
       `${chalk.greenBright("✔")} Account with alias ${chalk.yellowBright(

src/commands/account/default.ts

@@ -0,0 +1,83 @@
+import { Args, Flags } from "@oclif/core";
+import chalk from "chalk";
+import { SwankySystemConfig } from "../../types/index.js";
+import inquirer from "inquirer";
+import { SwankyCommand } from "../../lib/swankyCommand.js";
+import { ConfigError, FileError } from "../../lib/errors.js";
+import { getSwankyConfig, isLocalConfigCheck } from "../../lib/index.js";
+import { ConfigBuilder } from "../../lib/config-builder.js";
+
+export class DefaultAccount extends SwankyCommand<typeof DefaultAccount> {
+  static description = "Set default account to use";
+
+  static flags = {
+    global: Flags.boolean({
+      char: "g",
+      description: "Set default account globally in Swanky system config.",
+    }),
+  };
+
+  static args = {
+    accountAlias: Args.string({
+      name: "accountAlias",
+      required: false,
+      description: "Alias of account to be used as default",
+    }),
+  };
+
+  constructor(argv: string[], baseConfig: any) {
+    super(argv, baseConfig);
+    (this.constructor as typeof SwankyCommand).ENSURE_SWANKY_CONFIG = false;
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(DefaultAccount);
+
+    const configType = flags.global ? "global" : isLocalConfigCheck() ? "local" : "global";
+    const config = configType === "global" ? getSwankyConfig("global") : this.swankyConfig;
+
+    const accountAlias = args.accountAlias ?? (await this.promptForAccountAlias(config));
+    this.ensureAccountExists(config, accountAlias);
+
+    const configBuilder = new ConfigBuilder(config);
+    configBuilder.setDefaultAccount(accountAlias);
+
+    try {
+      await this.storeConfig(configBuilder.build(), configType);
+    } catch (cause) {
+      throw new FileError(`Error storing default account in ${configType} config`, {
+        cause,
+      });
+    }
+
+    this.log(
+      `${chalk.greenBright("✔")} Account with alias ${chalk.yellowBright(
+        accountAlias
+      )} set as default in ${configType} config`
+    );
+  }
+
+  private async promptForAccountAlias(config: SwankySystemConfig): Promise<string> {
+    const choices = config.accounts.map((account) => ({
+      name: `${account.alias} (${account.address})`,
+      value: account.alias,
+    }));
+
+    const answer = await inquirer.prompt([
+      {
+        type: "list",
+        name: "defaultAccount",
+        message: "Select default account",
+        choices: choices,
+      },
+    ]);
+
+    return answer.defaultAccount;
+  }
+
+  private ensureAccountExists(config: SwankySystemConfig, alias: string) {
+    const isSomeAccount = config.accounts.some((account) => account.alias === alias);
+    if (!isSomeAccount)
+      throw new ConfigError(`Provided account alias ${chalk.yellowBright(alias)} not found`);
+  }
+}

src/commands/account/list.ts

@@ -5,11 +5,36 @@ export class ListAccounts extends SwankyCommand<typeof ListAccounts> {
   static description = "List dev accounts stored in config";
   static aliases = [`account:ls`];
 
+  constructor(argv: string[], baseConfig: any) {
+    super(argv, baseConfig);
+    (this.constructor as typeof SwankyCommand).ENSURE_SWANKY_CONFIG = false;
+  }
+
   async run(): Promise<void> {
-    this.log(`${chalk.greenBright("✔")} Stored dev accounts:`);
+    const countOfDevAccounts = this.swankyConfig.accounts.filter((account) => account.isDev).length;
+
+    if(countOfDevAccounts !== 0) {
+      this.log(`${chalk.greenBright("✔")} Stored dev accounts:`);
+
+      for (const account of this.swankyConfig.accounts) {
+        if(account.isDev){
+          this.log(`\t${chalk.yellowBright("Alias: ")} ${account.alias}  \
+${chalk.yellowBright("Address: ")} ${account.address} ${this.swankyConfig.defaultAccount === account.alias ? chalk.greenBright("<- Default") : ""}`);
+        }
+      }
+    }
+
+    const countOfProdAccounts = this.swankyConfig.accounts.length - countOfDevAccounts;
+
+    if(countOfProdAccounts !== 0) {
+      this.log(`${chalk.greenBright("✔")} Stored prod accounts:`);
 
-    for (const account of this.swankyConfig.accounts) {
-      this.log(`\t${chalk.yellowBright("Alias: ")} ${account.alias}`);
+      for (const account of this.swankyConfig.accounts) {
+        if(!account.isDev){
+          this.log(`\t${chalk.yellowBright("Alias: ")} ${account.alias}  \
+${chalk.yellowBright("Address: ")} ${account.address} ${this.swankyConfig.defaultAccount === account.alias ? chalk.greenBright("<- Default") : ""}`);
+        }
+      }
     }
   }
 }

src/commands/check/index.ts

@@ -1,7 +1,7 @@
 import { Listr } from "listr2";
-import { commandStdoutOrNull } from "../../lib/index.js";
+import { commandStdoutOrNull, isLocalConfigCheck } from "../../lib/index.js";
 import { SwankyConfig } from "../../types/index.js";
-import { pathExistsSync, readJSON } from "fs-extra/esm";
+import { pathExistsSync} from "fs-extra/esm";
 import { readFileSync } from "fs";
 import path from "node:path";
 import TOML from "@iarna/toml";
@@ -19,14 +19,19 @@ interface Ctx {
     };
     contracts: Record<string, Record<string, string>>;
   };
-  swankyConfig?: SwankyConfig;
+  swankyConfig: SwankyConfig;
   mismatchedVersions?: Record<string, string>;
   looseDefinitionDetected: boolean;
 }
 
 export default class Check extends SwankyCommand<typeof Check> {
   static description = "Check installed package versions and compatibility";
 
+  constructor(argv: string[], baseConfig: any) {
+    super(argv, baseConfig);
+    (this.constructor as typeof SwankyCommand).ENSURE_SWANKY_CONFIG = false;
+  }
+
   public async run(): Promise<void> {
     const tasks = new Listr<Ctx>([
       {
@@ -61,11 +66,10 @@ export default class Check extends SwankyCommand<typeof Check> {
       },
       {
         title: "Read ink dependencies",
+        enabled: isLocalConfigCheck(),
+        skip: (ctx) => Object.keys(ctx.swankyConfig.contracts).length == 0,
         task: async (ctx) => {
-          const swankyConfig = await readJSON("swanky.config.json");
-          ctx.swankyConfig = swankyConfig;
-
-          for (const contract in swankyConfig.contracts) {
+          for (const contract in ctx.swankyConfig.contracts) {
             const tomlPath = path.resolve(`contracts/${contract}/Cargo.toml`);
             const doesCargoTomlExist = pathExistsSync(tomlPath);
             if (!doesCargoTomlExist) {
@@ -90,13 +94,15 @@ export default class Check extends SwankyCommand<typeof Check> {
       },
       {
         title: "Verify ink version",
+        enabled: isLocalConfigCheck(),
+        skip: (ctx) => Object.keys(ctx.swankyConfig.contracts).length == 0,
         task: async (ctx) => {
-          const supportedInk = ctx.swankyConfig?.node.supportedInk;
+          const supportedInk = ctx.swankyConfig.node.supportedInk;
 
           const mismatched: Record<string, string> = {};
           Object.entries(ctx.versions.contracts).forEach(([contract, inkPackages]) => {
             Object.entries(inkPackages).forEach(([inkPackage, version]) => {
-              if (semver.gt(version, supportedInk!)) {
+              if (semver.gt(version, supportedInk)) {
                 mismatched[
                   `${contract}-${inkPackage}`
                 ] = `Version of ${inkPackage} (${version}) in ${contract} is higher than supported ink version (${supportedInk})`;
@@ -114,12 +120,15 @@ export default class Check extends SwankyCommand<typeof Check> {
     ]);
     const context = await tasks.run({
       versions: { tools: {}, contracts: {} },
+      swankyConfig: this.swankyConfig,
       looseDefinitionDetected: false,
     });
     console.log(context.versions);
-    Object.values(context.mismatchedVersions as any).forEach((mismatch) =>
-      console.error(`[ERROR] ${mismatch as string}`)
-    );
+    if(context.mismatchedVersions !== undefined) {
+      Object.values(context.mismatchedVersions).forEach((mismatch) =>
+        console.error(`[ERROR] ${mismatch}`)
+      );
+    }
     if (context.looseDefinitionDetected) {
       console.log(`\n[WARNING]Some of the ink dependencies do not have a fixed version.
       This can lead to accidentally installing version higher than supported by the node.

src/commands/contract/compile.ts

@@ -1,6 +1,6 @@
 import { Args, Flags } from "@oclif/core";
 import path from "node:path";
-import { storeArtifacts, Spinner, generateTypes } from "../../lib/index.js";
+import { storeArtifacts, Spinner, generateTypes, configName } from "../../lib/index.js";
 import { spawn } from "node:child_process";
 import { pathExists } from "fs-extra/esm";
 import { SwankyCommand } from "../../lib/swankyCommand.js";
@@ -49,7 +49,7 @@ export class CompileContract extends SwankyCommand<typeof CompileContract> {
       const contractInfo = this.swankyConfig.contracts[contractName];
       if (!contractInfo) {
         throw new ConfigError(
-          `Cannot find contract info for ${contractName} contract in swanky.config.json`
+          `Cannot find contract info for ${contractName} contract in "${configName()}"`
         );
       }
       const contractPath = path.resolve("contracts", contractInfo.name);

src/commands/contract/deploy.ts

@@ -1,8 +1,14 @@
 import { Args, Flags } from "@oclif/core";
-import path from "node:path";
-import { writeJSON } from "fs-extra/esm";
 import { cryptoWaitReady } from "@polkadot/util-crypto/crypto";
-import { resolveNetworkUrl, ChainApi, ChainAccount, decrypt, AbiType } from "../../lib/index.js";
+import {
+  resolveNetworkUrl,
+  ChainApi,
+  ChainAccount,
+  decrypt,
+  AbiType,
+  ensureAccountIsSet,
+  configName,
+} from "../../lib/index.js";
 import { AccountData, Encrypted } from "../../types/index.js";
 import inquirer from "inquirer";
 import chalk from "chalk";
@@ -15,8 +21,7 @@ export class DeployContract extends SwankyCommand<typeof DeployContract> {
 
   static flags = {
     account: Flags.string({
-      required: true,
-      description: "Alias of account to be used",
+      description: "Account alias to deploy contract with",
     }),
     gas: Flags.integer({
       char: "g",
@@ -32,6 +37,7 @@ export class DeployContract extends SwankyCommand<typeof DeployContract> {
     }),
     network: Flags.string({
       char: "n",
+      default: "local",
       description: "Network name to connect to",
     }),
   };
@@ -50,7 +56,7 @@ export class DeployContract extends SwankyCommand<typeof DeployContract> {
     const contractRecord = this.swankyConfig.contracts[args.contractName];
     if (!contractRecord) {
       throw new ConfigError(
-        `Cannot find a contract named ${args.contractName} in swanky.config.json`
+        `Cannot find a contract named ${args.contractName} in "${configName()}"`
       );
     }
 
@@ -70,11 +76,21 @@ export class DeployContract extends SwankyCommand<typeof DeployContract> {
       );
     }
 
+    ensureAccountIsSet(flags.account, this.swankyConfig);
+
+    const accountAlias = flags.account ?? this.swankyConfig.defaultAccount;
+
     const accountData = this.swankyConfig.accounts.find(
-      (account: AccountData) => account.alias === flags.account
+      (account: AccountData) => account.alias === accountAlias
     );
     if (!accountData) {
-      throw new ConfigError("Provided account alias not found in swanky.config.json");
+      throw new ConfigError(`Provided account alias ${chalk.yellowBright(accountAlias)} not found in "${configName()}"`);
+    }
+
+    if (accountData.isDev && flags.network !== "local") {
+      throw new ConfigError(
+        `Account ${accountAlias} is a DEV account and can only be used with local network`
+      );
     }
 
     const mnemonic = accountData.isDev
@@ -134,13 +150,11 @@ export class DeployContract extends SwankyCommand<typeof DeployContract> {
           timestamp: Date.now(),
           address: contractAddress,
           networkUrl,
-          deployerAlias: flags.account,
+          deployerAlias: accountAlias!,
         },
       ];
 
-      await writeJSON(path.resolve("swanky.config.json"), this.swankyConfig, {
-        spaces: 2,
-      });
+      await this.storeConfig(this.swankyConfig, 'local');
     }, "Writing config");
 
     this.log(`Contract deployed!`);

src/commands/contract/explain.ts

@@ -2,6 +2,7 @@ import { SwankyCommand } from "../../lib/swankyCommand.js";
 import { Args } from "@oclif/core";
 import { Contract } from "../../lib/contract.js";
 import { ConfigError, FileError } from "../../lib/errors.js";
+import { configName } from "../../lib/index.js";
 
 export class ExplainContract extends SwankyCommand<typeof ExplainContract> {
   static description = "Explain contract messages based on the contracts' metadata";
@@ -20,7 +21,7 @@ export class ExplainContract extends SwankyCommand<typeof ExplainContract> {
     const contractRecord = this.swankyConfig.contracts[args.contractName];
     if (!contractRecord) {
       throw new ConfigError(
-        `Cannot find a contract named ${args.contractName} in swanky.config.json`
+        `Cannot find a contract named ${args.contractName} in "${configName()}"`
       );
     }