@vault77/summon 2.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Humble Digital, llc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,192 @@
+# summonTheWarlord — a VAULT77 🔐77 relic
+
+![Release](https://img.shields.io/github/v/release/monthviewsales/summonTheWarlord)
+![Node](https://img.shields.io/badge/node-%3E%3D18.x-brightgreen)
+![Platform](https://img.shields.io/badge/platform-macOS-blue)
+
+**Version:** 2.0.1
+
+> _Relic software unearthed from VAULT77.  
+> For trench operators only. macOS‑native. Handle with care._  
+> It executes trades with speed and precision — a lifeline to save our futures.
+
+---
+
+⚠️ **Operator notice:** summonTheWarlord executes live on‑chain swaps. Always verify token mints, amounts, and configuration values before execution. If you buy crap its your fault.
+
+## Requirements
+
+- Node.js >= 18
+- A [SolanaTracker.io](https://www.solanatracker.io/?ref=0NGJ5PPN) account
+- macOS (required for native Keychain security and system notifications; other operating systems are not supported)
+
+---
+
+## 📡 Connect with VAULT77
+
+- **VAULT77 Community:** https://x.com/i/communities/1962257350309650488
+- **Telegram:** https://t.me/BurnWalletBroadcast
+
+---
+
+# ⚡️ Step‑by‑Step Quickstart Guide
+
+### 1. Install from npm
+
+```bash
+npm install -g @vault77/summon
+```
+
+### 2. First Run — Initialize Wallet + Permissions
+
+```bash
+summon setup
+```
+
+This:
+
+- Creates/updates your config (RPC URL, slippage, priority fees, etc.)
+- Stores your private key securely in macOS Keychain
+- Prompts macOS notification permissions (optional)
+
+---
+
+# ⚔️ Trading Examples
+
+### Buy with 0.1 SOL
+
+```bash
+summon buy <TOKEN_MINT> 0.1
+```
+
+### Sell 50% of holdings
+
+```bash
+summon sell <TOKEN_MINT> 50%
+```
+
+---
+
+# 🧰 Local Development (optional)
+
+```bash
+git clone https://github.com/monthviewsales/summonTheWarlord.git
+cd summonTheWarlord
+npm install
+node summon-cli.js setup
+```
+
+---
+
+# 🛠 Upgrading
+
+```bash
+npm install -g @vault77/summon@latest
+```
+
+---
+
+# 👁‍🗨 For Coding Agents & Contributors
+
+See **AGENTS.md** for building conventions, coding rules, and automation guidance.
+
+---
+
+# 🛡 Support
+
+- **VAULT77 Community:** https://x.com/i/communities/1962257350309650488
+- **Telegram:** https://t.me/BurnWalletBroadcast
+
+---
+
+# ⚙️ Configuration
+
+The CLI stores configuration in:
+
+- `~/Library/Application Support/summonTheWarlord/config.json`
+
+You can manage it with:
+
+```bash
+summon config view
+summon config edit
+summon config set <key> <value>
+summon config wizard
+summon config list
+```
+
+Tip: use `summon config wizard` for validated prompts and selector-based choices.
+
+Key options:
+
+- `rpcUrl` (the CLI will append `advancedTx=true` if missing)
+- `slippage` (number or `"auto"`)
+- `priorityFee` (number or `"auto"`)
+- `priorityFeeLevel` (`min|low|medium|high|veryHigh`) — required when `priorityFee="auto"`
+- `txVersion` (`v0` or `legacy`)
+- `showQuoteDetails` (`true`/`false`)
+- `DEBUG_MODE` (`true`/`false`)
+- `notificationsEnabled` (`true`/`false`)
+- `jito.enabled` (`true`/`false`)
+- `jito.tip` (number, SOL)
+
+If you want fewer popups, set `notificationsEnabled` to `false`.
+
+Override config location (useful for CI or tests):
+
+- `SUMMON_CONFIG_HOME=/custom/config/dir`
+- `SUMMON_CONFIG_PATH=/custom/path/config.json`
+
+Private keys are never stored in this file. Use:
+
+```bash
+summon keychain store
+summon keychain unlock
+summon keychain delete
+```
+
+---
+
+# 🧪 Testing & Linting
+
+```bash
+npm test
+npm run lint
+```
+
+---
+
+# 🩺 Diagnostics
+
+```bash
+summon doctor
+```
+
+Runs checks for config, Keychain access, RPC reachability, swap API health, and macOS notifications (skipped when disabled).
+
+---
+
+# 🫡 Open Source Thanks
+
+This never would have been possible without Open Source Software and these contributions.
+
+Dependencies:
+
+- `@solana/web3.js` — [MIT](https://github.com/solana-foundation/solana-web3.js/blob/HEAD/LICENSE)
+- `axios` — [MIT](https://github.com/axios/axios/blob/HEAD/LICENSE)
+- `bs58` — [MIT](https://github.com/cryptocoinjs/bs58/blob/HEAD/LICENSE)
+- `commander` — [MIT](https://github.com/tj/commander.js/blob/HEAD/LICENSE)
+- `fs-extra` — [MIT](https://github.com/jprichardson/node-fs-extra/blob/HEAD/LICENSE)
+- `keytar` — [MIT](https://github.com/atom/node-keytar/blob/HEAD/LICENSE)
+- `npm` — [Artistic-2.0](https://github.com/npm/cli/blob/HEAD/LICENSE)
+- `open` — [MIT](https://github.com/sindresorhus/open/blob/HEAD/LICENSE)
+- `solana-swap` — [ISC](https://github.com/YZYLAB/solana-swap/blob/HEAD/LICENSE)
+
+Tooling:
+
+- `eslint` — [MIT](https://github.com/eslint/eslint/blob/HEAD/LICENSE)
+- `eslint-config-standard` — [MIT](https://github.com/standard/eslint-config-standard/blob/HEAD/LICENSE)
+- `eslint-plugin-import` — [MIT](https://github.com/import-js/eslint-plugin-import/blob/HEAD/LICENSE)
+- `eslint-plugin-n` — [MIT](https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/LICENSE)
+- `eslint-plugin-promise` — [ISC](https://github.com/eslint-community/eslint-plugin-promise/blob/HEAD/LICENSE)
+- `jest` — [MIT](https://github.com/jestjs/jest/blob/HEAD/LICENSE)

package/lib/config.js

@@ -0,0 +1,305 @@
+import fs from "fs-extra";
+import os from "os";
+import path from "path";
+import { spawnSync } from "child_process";
+import { ConfigError } from "./errors.js";
+import { logger } from "../utils/logger.js";
+
+// Application name for config directory
+const APP_NAME = "summonTheWarlord";
+
+export const PRIORITY_FEE_LEVELS = ["min", "low", "medium", "high", "veryHigh"];
+export const TX_VERSIONS = ["v0", "legacy"];
+const DEFAULT_JITO = { enabled: false, tip: 0.0001 };
+const DEPRECATED_KEYS = new Set(["swapAPIKey"]);
+
+// Default configuration values
+// Note: walletSecretKey has been moved to macOS Keychain storage
+export const DEFAULT_CONFIG = {
+  //  Welcome to summonTheWarlord, a CLI for simple fast trading on Solana.
+  //  Its required that you use SolanaTracker.io as your RPC as they also provide required APIs.
+  //  This is a free public endpoint and may have issues.
+  //  You can get a free account at https://www.solanatracker.io/solana-rpc
+  //  Replace the URL with the new one provided and keep '?advancedTx=true' after your API Key.
+  rpcUrl: "https://rpc.solanatracker.io/public?advancedTx=true",
+  slippage: 10,               // Maximum acceptable slippage percentage (e.g., 10) or "auto"
+  priorityFee: "auto",        // Amount in SOL or "auto"
+  priorityFeeLevel: "medium", // "min","low","medium","high","veryHigh"
+  txVersion: "v0",            // "v0" or "legacy"
+  showQuoteDetails: false,      //  Outputs the JSON swap response to the console
+  DEBUG_MODE: false,          // Enable debug logging
+  notificationsEnabled: true, // Enable macOS notifications
+  jito: { ...DEFAULT_JITO },  // Jito bundle settings
+  // walletSecretKey: "",       // Deprecated: now stored in macOS Keychain,
+};
+
+export const CONFIG_KEYS = Object.freeze(Object.keys(DEFAULT_CONFIG));
+
+const BOOLEAN_KEYS = new Set(["showQuoteDetails", "DEBUG_MODE", "notificationsEnabled"]);
+const STRING_KEYS = new Set(["rpcUrl"]);
+
+function coerceBoolean(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    const lowered = value.trim().toLowerCase();
+    if (lowered === "true") return true;
+    if (lowered === "false") return false;
+  }
+  return null;
+}
+
+function coerceNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) return null;
+    const num = Number(trimmed);
+    if (Number.isFinite(num)) return num;
+  }
+  return null;
+}
+
+export function parseConfigValue(raw) {
+  const trimmed = String(raw ?? "").trim();
+  const bool = coerceBoolean(trimmed);
+  if (bool !== null) return bool;
+  if (trimmed !== "") {
+    const num = Number(trimmed);
+    if (!Number.isNaN(num)) return num;
+  }
+  return raw;
+}
+
+function evaluateConfigValue(key, value) {
+  if (key === "slippage") {
+    if (typeof value === "string" && value.trim().toLowerCase() === "auto") {
+      return { normalized: "auto" };
+    }
+    const num = coerceNumber(value);
+    if (num === null || num < 0) {
+      return { error: "Invalid slippage. Use a non-negative number or \"auto\"." };
+    }
+    return { normalized: num };
+  }
+  if (key === "priorityFee") {
+    if (typeof value === "string" && value.trim().toLowerCase() === "auto") {
+      return { normalized: "auto" };
+    }
+    const num = coerceNumber(value);
+    if (num === null || num < 0) {
+      return { error: "Invalid priorityFee. Use a non-negative number or \"auto\"." };
+    }
+    return { normalized: num };
+  }
+  if (key === "priorityFeeLevel") {
+    if (typeof value !== "string") {
+      return { error: `Invalid priorityFeeLevel. Use one of ${PRIORITY_FEE_LEVELS.join(", ")}.` };
+    }
+    const normalizedLevel = value.trim();
+    const match = PRIORITY_FEE_LEVELS.find((level) => level.toLowerCase() === normalizedLevel.toLowerCase());
+    if (!match) {
+      return { error: `Invalid priorityFeeLevel. Use one of ${PRIORITY_FEE_LEVELS.join(", ")}.` };
+    }
+    return { normalized: match };
+  }
+  if (key === "txVersion") {
+    if (typeof value !== "string") {
+      return { error: `Invalid txVersion. Use ${TX_VERSIONS.join(" or ")}.` };
+    }
+    const normalizedVersion = value.trim();
+    const match = TX_VERSIONS.find((version) => version.toLowerCase() === normalizedVersion.toLowerCase());
+    if (!match) {
+      return { error: `Invalid txVersion. Use ${TX_VERSIONS.join(" or ")}.` };
+    }
+    return { normalized: match };
+  }
+  if (key === "jito") {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return { error: "Invalid jito config. Expected an object with enabled and tip." };
+    }
+    const enabledRaw = value.enabled === undefined ? DEFAULT_JITO.enabled : value.enabled;
+    const enabled = coerceBoolean(enabledRaw);
+    if (enabled === null) {
+      return { error: "Invalid jito.enabled. Use true or false." };
+    }
+    const tipRaw = value.tip === undefined ? DEFAULT_JITO.tip : value.tip;
+    const tip = coerceNumber(tipRaw);
+    if (tip === null || tip < 0) {
+      return { error: "Invalid jito.tip. Use a non-negative number." };
+    }
+    return { normalized: { enabled, tip } };
+  }
+  if (BOOLEAN_KEYS.has(key)) {
+    const bool = coerceBoolean(value);
+    if (bool === null) {
+      return { error: `Invalid ${key}. Use true or false.` };
+    }
+    return { normalized: bool };
+  }
+  if (STRING_KEYS.has(key)) {
+    if (typeof value !== "string") {
+      return { error: `Invalid ${key}. Expected a string.` };
+    }
+    if (key === "rpcUrl" && value.trim() === "") {
+      return { error: "Invalid rpcUrl. Expected a non-empty string." };
+    }
+    return { normalized: value };
+  }
+  return { normalized: value };
+}
+
+export function normalizeConfigValue(key, value, { strict = false } = {}) {
+  const { normalized, error } = evaluateConfigValue(key, value);
+  if (error) {
+    if (strict) {
+      throw new ConfigError(error, { details: { key, value } });
+    }
+    return DEFAULT_CONFIG[key];
+  }
+  return normalized;
+}
+
+export function normalizeConfig(cfg, { strict = false } = {}) {
+  const normalized = { ...cfg };
+  const warnings = [];
+  let changed = false;
+
+  for (const key of DEPRECATED_KEYS) {
+    if (key in normalized) {
+      delete normalized[key];
+      changed = true;
+    }
+  }
+
+  for (const [key, value] of Object.entries(DEFAULT_CONFIG)) {
+    if (!(key in normalized)) {
+      normalized[key] = value;
+      changed = true;
+    }
+  }
+
+  for (const key of Object.keys(DEFAULT_CONFIG)) {
+    const originalValue = normalized[key];
+    const { normalized: nextValue, error } = evaluateConfigValue(key, originalValue);
+    if (error) {
+      if (strict) {
+        throw new ConfigError(error, { details: { key, value: originalValue } });
+      }
+      normalized[key] = DEFAULT_CONFIG[key];
+      warnings.push({ key, message: error });
+      changed = true;
+      continue;
+    }
+    if (!Object.is(originalValue, nextValue)) {
+      normalized[key] = nextValue;
+      changed = true;
+    }
+  }
+
+  return { config: normalized, changed, warnings };
+}
+
+/**
+ * Compute the path to the config file.
+ * - On macOS: ~/Library/Application Support/summonTheWarlord/config.json
+ * - Else:      $XDG_CONFIG_HOME/summonTheWarlord/config.json (or ~/.config/…)
+ */
+export function getConfigPath() {
+  const home = os.homedir();
+  if (process.env.SUMMON_CONFIG_PATH) {
+    return process.env.SUMMON_CONFIG_PATH;
+  }
+  if (process.env.SUMMON_CONFIG_HOME) {
+    return path.join(process.env.SUMMON_CONFIG_HOME, APP_NAME, "config.json");
+  }
+  if (process.platform === "darwin") {
+    const appSupport = path.join(home, "Library", "Application Support", APP_NAME);
+    return path.join(appSupport, "config.json");
+  }
+  const xdgConfig = process.env.XDG_CONFIG_HOME || path.join(home, ".config");
+  return path.join(xdgConfig, APP_NAME, "config.json");
+}
+
+/**
+ * Load the config, writing defaults if the file didn't exist.
+ * Also merges in any new keys from DEFAULT_CONFIG.
+ */
+export async function loadConfig() {
+  const configPath = getConfigPath();
+
+  // If missing, write out defaults
+  if (!await fs.pathExists(configPath)) {
+    await fs.ensureDir(path.dirname(configPath), { mode: 0o700 });
+    await fs.writeJson(configPath, DEFAULT_CONFIG, { spaces: 2 });
+    await fs.chmod(configPath, 0o600);
+    return { ...DEFAULT_CONFIG };
+  }
+
+  // Read existing, merge missing defaults
+  let cfg;
+  try {
+    cfg = await fs.readJson(configPath);
+  } catch (err) {
+    let backupPath;
+    try {
+      if (await fs.pathExists(configPath)) {
+        backupPath = `${configPath}.invalid-${Date.now()}`;
+        await fs.move(configPath, backupPath, { overwrite: true });
+      }
+    } catch (moveErr) {
+      console.warn(`⚠️ Unable to back up invalid config: ${moveErr.message}`);
+    }
+
+    await fs.ensureDir(path.dirname(configPath), { mode: 0o700 });
+    await fs.writeJson(configPath, DEFAULT_CONFIG, { spaces: 2 });
+    await fs.chmod(configPath, 0o600);
+
+    if (backupPath) {
+      logger.warn("Config was invalid and has been reset.", { backupPath });
+    } else {
+      logger.warn("Config was invalid and has been reset.");
+    }
+    return { ...DEFAULT_CONFIG };
+  }
+  let updated = false;
+  for (const [key, value] of Object.entries(DEFAULT_CONFIG)) {
+    if (!(key in cfg)) {
+      cfg[key] = value;
+      updated = true;
+    }
+  }
+  const { config: normalized, changed, warnings } = normalizeConfig(cfg);
+  warnings.forEach((warning) => {
+    logger.warn(warning.message, { key: warning.key });
+  });
+  if (updated || changed) {
+    await fs.writeJson(configPath, normalized, { spaces: 2 });
+    await fs.chmod(configPath, 0o600);
+  }
+  return normalized;
+}
+
+/**
+ * Save the given config object back to disk (with secure perms).
+ */
+export async function saveConfig(cfg) {
+  const configPath = getConfigPath();
+  const { config: normalized, warnings } = normalizeConfig(cfg);
+  warnings.forEach((warning) => {
+    logger.warn(warning.message, { key: warning.key });
+  });
+  await fs.ensureDir(path.dirname(configPath), { mode: 0o700 });
+  // Note: walletSecretKey is now stored securely in the macOS Keychain, not in this file
+  await fs.writeJson(configPath, normalized, { spaces: 2 });
+  await fs.chmod(configPath, 0o600);
+}
+
+/**
+ * Open the config file in the user's $EDITOR.
+ */
+export async function editConfig() {
+  const configPath = getConfigPath();
+  await loadConfig();
+  const editor = process.env.EDITOR || "vim";
+  spawnSync(editor, [configPath], { stdio: "inherit" });
+}

package/lib/doctor.js

@@ -0,0 +1,143 @@
+import { loadConfig } from "./config.js";
+import { getPrivateKey, hasPrivateKey } from "../utils/keychain.js";
+import { notify } from "../utils/notify.js";
+import { ensureAdvancedTx, getSwapClient } from "./swapClient.js";
+
+const WRAPPED_SOL_MINT = "So11111111111111111111111111111111111111112";
+const TRUMP_MINT = "6p6xgHyF7AeE6TZkSmFsko444wqoP15icUSqi2jfGiPN";
+const MIN_SWAP_SOL = 0.0001;
+
+function makeResult(name, status, message, details) {
+  return { name, status, message, details };
+}
+
+async function checkConfig() {
+  try {
+    const cfg = await loadConfig();
+    return { cfg, result: makeResult("config", "ok", "Loaded and normalized config.") };
+  } catch (err) {
+    return { cfg: null, result: makeResult("config", "fail", "Failed to load config.", err?.message) };
+  }
+}
+
+async function checkKeychain() {
+  try {
+    const exists = await hasPrivateKey();
+    if (!exists) {
+      return { ok: false, result: makeResult("keychain", "fail", "No private key stored.") };
+    }
+    await getPrivateKey();
+    return { ok: true, result: makeResult("keychain", "ok", "Private key accessible.") };
+  } catch (err) {
+    return { ok: false, result: makeResult("keychain", "fail", "Unable to read private key.", err?.message) };
+  }
+}
+
+async function checkRpc(rpcUrl) {
+  if (!rpcUrl) {
+    return makeResult("rpc", "fail", "RPC URL not configured.");
+  }
+  const healthUrl = ensureAdvancedTx(rpcUrl);
+  try {
+    const res = await fetch(healthUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "getHealth" }),
+    });
+    if (!res.ok) {
+      return makeResult("rpc", "fail", "RPC health check failed.", `HTTP ${res.status}`);
+    }
+    const body = await res.json();
+    if (body.result !== "ok") {
+      return makeResult("rpc", "fail", "RPC returned unhealthy status.", JSON.stringify(body));
+    }
+    return makeResult("rpc", "ok", "RPC reachable.");
+  } catch (err) {
+    return makeResult("rpc", "fail", "RPC health check error.", err?.message);
+  }
+}
+
+async function checkSwapApi(cfg, keychainOk) {
+  if (!cfg) {
+    return makeResult("swap", "skip", "Swap check skipped (config unavailable).");
+  }
+  if (!keychainOk) {
+    return makeResult("swap", "skip", "Swap check skipped (missing keychain).");
+  }
+  try {
+    const tracker = await getSwapClient();
+    const opts = {
+      txVersion: cfg.txVersion || "v0",
+      priorityFeeLevel: cfg.priorityFeeLevel || "medium",
+      fee: { wallet: "8aBKXBErcp1Bi5LmaeGnaXCj9ot7PE4T2wuqHQfeT5E6", percentage: 0.4 },
+      feeType: "add",
+    };
+    const swapResp = await tracker.getSwapInstructions(
+      WRAPPED_SOL_MINT,
+      TRUMP_MINT,
+      MIN_SWAP_SOL,
+      cfg.slippage,
+      tracker.keypair.publicKey.toBase58(),
+      cfg.priorityFee,
+      false,
+      opts
+    );
+    const quote = swapResp?.quote ?? swapResp?.rate;
+    if (!quote) {
+      return makeResult("swap", "fail", "Swap API response missing quote.");
+    }
+    return makeResult("swap", "ok", "Swap API reachable.");
+  } catch (err) {
+    return makeResult("swap", "fail", "Swap API check failed.", err?.message);
+  }
+}
+
+async function checkNotifications(cfg) {
+  if (cfg?.notificationsEnabled === false) {
+    return makeResult("notifications", "skip", "Notifications disabled in config.");
+  }
+  if (process.platform !== "darwin") {
+    return makeResult("notifications", "skip", "Notifications are macOS-only.");
+  }
+  try {
+    const ok = notify({
+      title: "summonTheWarlord",
+      subtitle: "Doctor check",
+      message: "Notification test from summon doctor.",
+      sound: "Ping",
+      throwOnError: true,
+    });
+    if (!ok) {
+      return makeResult("notifications", "fail", "Notification failed.");
+    }
+    return makeResult("notifications", "ok", "Notification sent.");
+  } catch (err) {
+    return makeResult("notifications", "fail", "Notification failed.", err?.message);
+  }
+}
+
+export async function runDoctor({ verbose = false } = {}) {
+  const results = [];
+  const { cfg, result: configResult } = await checkConfig();
+  results.push(configResult);
+
+  const { ok: keychainOk, result: keychainResult } = await checkKeychain();
+  results.push(keychainResult);
+
+  const rpcResult = await checkRpc(cfg?.rpcUrl);
+  results.push(rpcResult);
+
+  const swapResult = await checkSwapApi(cfg, keychainOk);
+  results.push(swapResult);
+
+  const notifyResult = await checkNotifications(cfg);
+  results.push(notifyResult);
+
+  if (verbose) {
+    return results.map((item) => ({
+      ...item,
+      details: item.details || undefined,
+    }));
+  }
+  return results;
+}

package/lib/errors.js

@@ -0,0 +1,18 @@
+export class AppError extends Error {
+  constructor(message, { cause, details } = {}) {
+    super(message);
+    this.name = this.constructor.name;
+    if (cause) {
+      this.cause = cause;
+    }
+    if (details) {
+      this.details = details;
+    }
+  }
+}
+
+export class ConfigError extends AppError {}
+export class KeychainError extends AppError {}
+export class SwapError extends AppError {}
+export class NotificationError extends AppError {}
+export class DoctorError extends AppError {}