Add random mnemonic generation in seed input screen

Before bliss
Add variable step
2026-05-19 13:31:01 +02:00 · 2026-05-16 05:59:55 +00:00 · 2026-05-11 12:18:47 +00:00 · 2026-05-11 10:41:41 +00:00 · 2026-05-11 02:52:52 +00:00 · 2026-05-04 12:15:39 +00:00
77 changed files with 7497 additions and 3215 deletions
--- a/p2pkh-template.json
+++ b/p2pkh-template.json
--- a/package-lock.json
+++ b/package-lock.json
@@ -11,11 +11,12 @@
      "dependencies": {
        "@bitauth/libauth": "^3.0.0",
        "@electrum-cash/protocol": "^2.3.1",
-        "@xo-cash/crypto": "file:../crypto",
+        "@generalprotocols/oracle-client": "^0.0.1-development.11945476152",
+        "@xo-cash/crypto": "^0.0.1",
        "@xo-cash/engine": "file:../engine",
        "@xo-cash/state": "file:../state",
        "@xo-cash/templates": "file:../templates",
-        "@xo-cash/types": "file:../types",
+        "@xo-cash/types": "^0.0.1",
        "better-sqlite3": "^12.6.2",
        "clipboardy": "^5.1.0",
        "ink": "^6.6.0",
@@ -40,38 +41,6 @@
        "vitest": "^4.1.2"
      }
    },
-    "../crypto": {
-      "name": "@xo-cash/crypto",
-      "version": "0.0.1",
-      "license": "MIT",
-      "dependencies": {
-        "@bitauth/libauth": "^3.1.0-next.8",
-        "@xo-cash/primitives": "0.0.1",
-        "@xo-cash/types": "0.0.1"
-      },
-      "devDependencies": {
-        "@chalp/eslint-airbnb": "^1.3.0",
-        "@generalprotocols/cspell-dictionary": "^1.0.1",
-        "@stylistic/eslint-plugin": "^5.7.0",
-        "@typescript-eslint/eslint-plugin": "^8.53.1",
-        "@typescript-eslint/parser": "^8.53.1",
-        "@vitest/coverage-v8": "^4.0.17",
-        "@viz-kit/esbuild-analyzer": "^1.0.0",
-        "@xo-cash/eslint-config": "1.0.1",
-        "cspell": "^9.6.0",
-        "eslint": "^9.39.2",
-        "prettier": "^3.6.2",
-        "tsdown": "^0.20.0-beta.4",
-        "typedoc": "^0.28.16",
-        "typedoc-plugin-coverage": "^4.0.2",
-        "typescript": "^5.3.2",
-        "typescript-eslint": "^8.53.1",
-        "vitest": "^4.0.17"
-      },
-      "engines": {
-        "node": ">=18.0.0"
-      }
-    },
    "../engine": {
      "name": "@xo-cash/engine",
      "version": "0.0.1",
@@ -82,9 +51,10 @@
        "@electrum-cash/network": "^4.2.2",
        "@electrum-cash/protocol": "^2.3.1",
        "@electrum-cash/servers": "^3.1.0",
-        "@xo-cash/crypto": "0.0.1",
+        "@xo-cash/crypto": "file:../crypto",
        "@xo-cash/primitives": "0.0.1",
-        "@xo-cash/state": "0.0.1",
+        "@xo-cash/state": "0.0.2",
+        "@xo-cash/templates": "0.0.1",
        "@xo-cash/types": "0.0.1",
        "@xo-cash/utils": "0.0.1",
        "eventemitter3": "^5.0.1"
@@ -107,18 +77,15 @@
        "typescript": "^5.3.2",
        "typescript-eslint": "^8.53.1",
        "vitest": "^4.0.17"
-      },
-      "engines": {
-        "node": ">=18.0.0"
      }
    },
    "../state": {
      "name": "@xo-cash/state",
-      "version": "0.0.1",
+      "version": "0.0.2",
      "license": "MIT",
      "dependencies": {
        "@bitauth/libauth": "^3.1.0-next.8",
-        "@xo-cash/types": "0.0.1-development.13730885533",
+        "@xo-cash/types": "0.0.1",
        "@xo-cash/utils": "0.0.1",
        "better-sqlite3": "^12.5.0",
        "idb": "^8.0.3",
@@ -151,34 +118,7 @@
      "version": "0.0.1",
      "license": "MIT",
      "dependencies": {
-        "@xo-cash/types": "0.0.1-development.13504604083"
-      },
-      "devDependencies": {
-        "@chalp/eslint-airbnb": "^1.3.0",
-        "@generalprotocols/cspell-dictionary": "^1.0.1",
-        "@stylistic/eslint-plugin": "^5.7.0",
-        "@typescript-eslint/eslint-plugin": "^8.53.1",
-        "@typescript-eslint/parser": "^8.53.1",
-        "@vitest/coverage-v8": "^4.0.17",
-        "@viz-kit/esbuild-analyzer": "^1.0.0",
-        "@xo-cash/eslint-config": "1.0.1",
-        "cspell": "^9.6.0",
-        "eslint": "^9.39.2",
-        "prettier": "^3.6.2",
-        "tsdown": "^0.20.0-beta.4",
-        "typedoc": "^0.28.16",
-        "typedoc-plugin-coverage": "^4.0.2",
-        "typescript": "^5.3.2",
-        "typescript-eslint": "^8.53.1",
-        "vitest": "^4.0.17"
-      }
-    },
-    "../types": {
-      "name": "@xo-cash/types",
-      "version": "0.0.1",
-      "license": "MIT",
-      "dependencies": {
-        "@bitauth/libauth": "^3.1.0-next.8"
+        "@xo-cash/types": "0.0.1"
      },
      "devDependencies": {
        "@chalp/eslint-airbnb": "^1.3.0",
@@ -330,6 +270,16 @@
        "ws": "^8.13.0"
      }
    },
+    "node_modules/@generalprotocols/oracle-client": {
+      "version": "0.0.1-development.11945476152",
+      "resolved": "https://registry.npmjs.org/@generalprotocols/oracle-client/-/oracle-client-0.0.1-development.11945476152.tgz",
+      "integrity": "sha512-1Q43NfacrVfSbatCREzIX7U3DgACBUegNjV977y+pql+Fve03bOyTiUQClevymCi7M3T6mCyMzSEGT8zA6EZtQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@bitauth/libauth": "^3.0.0",
+        "zod": "^4.1.12"
+      }
+    },
    "node_modules/@jridgewell/resolve-uri": {
      "version": "3.1.2",
      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
@@ -960,13 +910,47 @@
      }
    },
    "node_modules/@xo-cash/crypto": {
-      "resolved": "../crypto",
-      "link": true
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/@xo-cash/crypto/-/crypto-0.0.1.tgz",
+      "integrity": "sha512-ZIa9MHAVCBJqo5uxyx/Tx/jTSyyJw1cfYfI48gEHqBIl5wyyxiZDx4eZvVWSr8uKgS5Tm3FXUkKQybvk5QGRIQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@bitauth/libauth": "^3.1.0-next.8",
+        "@xo-cash/primitives": "0.0.1",
+        "@xo-cash/types": "0.0.1"
+      }
+    },
+    "node_modules/@xo-cash/crypto/node_modules/@bitauth/libauth": {
+      "version": "3.1.0-next.8",
+      "resolved": "https://registry.npmjs.org/@bitauth/libauth/-/libauth-3.1.0-next.8.tgz",
+      "integrity": "sha512-Pm+Ju+YP3JeBLLTiVrBnia2wwE4G17r4XqpvPRMcklElJTe8J6x3JgKRg1by0Xm3ZY6UFxACkEAoSA+x419/zA==",
+      "license": "MIT",
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      }
    },
    "node_modules/@xo-cash/engine": {
      "resolved": "../engine",
      "link": true
    },
+    "node_modules/@xo-cash/primitives": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/@xo-cash/primitives/-/primitives-0.0.1.tgz",
+      "integrity": "sha512-medxVK9Sawj7oIDhWvTjTgzwf6BjGao6CXtQYJOUFi6NOO1eclb1PDjEmkG/4NeK3v7LQIN8QS60mTAGyS9FXg==",
+      "license": "MIT",
+      "dependencies": {
+        "@bitauth/libauth": "^3.1.0-next.8"
+      }
+    },
+    "node_modules/@xo-cash/primitives/node_modules/@bitauth/libauth": {
+      "version": "3.1.0-next.8",
+      "resolved": "https://registry.npmjs.org/@bitauth/libauth/-/libauth-3.1.0-next.8.tgz",
+      "integrity": "sha512-Pm+Ju+YP3JeBLLTiVrBnia2wwE4G17r4XqpvPRMcklElJTe8J6x3JgKRg1by0Xm3ZY6UFxACkEAoSA+x419/zA==",
+      "license": "MIT",
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      }
+    },
    "node_modules/@xo-cash/state": {
      "resolved": "../state",
      "link": true
@@ -976,8 +960,22 @@
      "link": true
    },
    "node_modules/@xo-cash/types": {
-      "resolved": "../types",
-      "link": true
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/@xo-cash/types/-/types-0.0.1.tgz",
+      "integrity": "sha512-BMwh2Y9+LqnTXYmdA7Nxi1NuK+AcsNWFoFGJVAvuY5TBfsbNIzWppjmrI2fAyj/RlSE3tATMxam+6CJb3RnDIA==",
+      "license": "MIT",
+      "dependencies": {
+        "@bitauth/libauth": "^3.1.0-next.8"
+      }
+    },
+    "node_modules/@xo-cash/types/node_modules/@bitauth/libauth": {
+      "version": "3.1.0-next.8",
+      "resolved": "https://registry.npmjs.org/@bitauth/libauth/-/libauth-3.1.0-next.8.tgz",
+      "integrity": "sha512-Pm+Ju+YP3JeBLLTiVrBnia2wwE4G17r4XqpvPRMcklElJTe8J6x3JgKRg1by0Xm3ZY6UFxACkEAoSA+x419/zA==",
+      "license": "MIT",
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      }
    },
    "node_modules/ansi-escapes": {
      "version": "7.2.0",
--- a/package.json
+++ b/package.json
@@ -16,10 +16,12 @@
    "test": "vitest --run --passWithNoTests",
    "test:watch": "vitest",
    "test:coverage": "vitest run --coverage --passWithNoTests",
-    "nuke": "tsx scripts/rm-dbs.ts",
-    "nuke:dry": "tsx scripts/rm-dbs.ts --dry",
    "format": "prettier --write \"**/*.{js,ts,md,json}\" --ignore-path .gitignore",
-    "format:check": "prettier --check ."
+    "format:check": "prettier --check .",
+    "autocomplete:install": "node dist/cli/index.js completions bash --install",
+    "autocomplete:install:bash": "node dist/cli/index.js completions bash --install",
+    "autocomplete:install:zsh": "node dist/cli/index.js completions zsh --install",
+    "autocomplete:install:fish": "node dist/cli/index.js completions fish --install"
  },
  "keywords": [
    "crypto",
@@ -33,11 +35,12 @@
  "dependencies": {
    "@bitauth/libauth": "^3.0.0",
    "@electrum-cash/protocol": "^2.3.1",
-    "@xo-cash/crypto": "file:../crypto",
+    "@generalprotocols/oracle-client": "^0.0.1-development.11945476152",
+    "@xo-cash/crypto": "^0.0.1",
    "@xo-cash/engine": "file:../engine",
    "@xo-cash/state": "file:../state",
    "@xo-cash/templates": "file:../templates",
-    "@xo-cash/types": "file:../types",
+    "@xo-cash/types": "^0.0.1",
    "better-sqlite3": "^12.6.2",
    "clipboardy": "^5.1.0",
    "ink": "^6.6.0",
--- a/readme.md
+++ b/readme.md
@@ -0,0 +1,107 @@
+# XO-CLI & XO-TUI
+
+## Installation
+
+### Full Installation
+```bash
+# Create a new directory since we are going to be pulling in engine too
+mkdir xo-terminal && cd xo-terminal
+
+# ----- Start Engine Setup -----
+# Clone the Engine Repo (Note, this uses harvey's fork of the engine repo to access the cli-test branch)
+git clone git@gitlab.com:Harvmaster/engine.git
+
+# Move into teh engine directory
+cd engine
+
+# Checkout the cli-test branch
+git checkout cli-test
+
+# Install the dependencies
+npm ci
+
+# Build the engine
+npm run build
+# ----- End Engine Setup -----
+
+# Move back to the top level directory
+cd ..
+
+# ----- Start State Setup -----
+# Clone the State Repo
+git clone git@gitlab.com:Harvmaster/state.git
+
+# Move into the state directory
+cd state
+
+git checkout in-memory-adapter
+
+# Install the dependencies
+npm ci
+
+# Build the state
+npm run build
+# ----- End State Setup -----
+
+# Move back to the top level directory
+cd ..
+
+# ----- Start CLI Setup -----
+# Clone the CLI Repo
+git clone git@git.harvmaster.com:Harvmaster/xo-cli.git 
+
+# Move into the cli directory
+cd xo-cli
+
+# Install the dependencies
+npm ci
+
+# Build the cli
+npm run build
+# ----- End CLI Setup -----
+```
+
+### Run TUI in dev mode
+
+```bash
+npm run dev
+```
+
+### Install globally
+
+```bash
+# (From the xo-cli directory)
+npm install -g .
+```
+
+### Install autocomplete completions (From the xo-cli directory)
+
+#### Install for bash
+```bash
+npm run autocomplete:install:bash
+```
+
+#### Install for zsh
+```bash
+npm run autocomplete:install:zsh
+```
+
+#### Install for fish
+```bash
+npm run autocomplete:install:fish
+```
+
+### Run the CLI
+```bash
+# If globally installed (Not really usable if not globally installed)
+xo-cli
+```
+
+### Run the TUI
+```bash
+# If globally installed
+xo-tui
+
+# If not globally installed
+npm run dev
+```
--- a/scripts/rm-dbs.ts
+++ b/scripts/rm-dbs.ts
@@ -1,40 +0,0 @@
-import fs from "fs/promises";
-
-/**
- * Remove all the databases without the use of external tools
- * TODO: Fix the ts linking issue here. Should just be adding this as a dir in tsconfig.json
- */
-const rmDbs = async (dry = false) => {
-  // First, we need to find all the database base files
-  // These end in either .db.sqlite, .sqlite, .db
-  // Get all the files in the current directory
-  const files = await fs.readdir("./");
-
-  // Filter out the files that end in .db.sqlite, .sqlite, .db
-  const dbFiles = files.filter(
-    (file) =>
-      file.endsWith(".db.sqlite") ||
-      file.endsWith(".sqlite") ||
-      file.endsWith(".db"),
-  );
-
-  // We need to remove all the files
-  await deleteFiles(dbFiles, dry);
-};
-
-const deleteFiles = async (files: string[], dry = false) => {
-  if (dry) {
-    console.log("Dry run, would delete:", files);
-    return;
-  }
-
-  await Promise.all(files.map((file) => fs.rm(file)));
-  console.log("All databases removed");
-};
-
-// Read args
-const args = process.argv.slice(2);
-const dry = args.includes("--dry");
-
-// Delete the files
-await rmDbs(dry);
--- a/scripts/template-to-json.ts
+++ b/scripts/template-to-json.ts
@@ -1,102 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-
-/**
- * This just convers the <template>.ts file to a <template>.json file.
- * Im fairly sure there is a util in the engine or engine-packages for this, but I decided to just keep it as simple as possible because I didn't feel like digging around for it.
- * 
- * Usage:
- * tsx scripts/template-to-json.ts ../templates/source/p2pkh.ts ./p2pkh.json p2pkhTemplate
- */
-
-/**
- * Prints usage to stderr and exits with a non-zero code.
- */
-function printUsageAndExit(): never {
-  console.error(
-    [
-      "Usage: tsx scripts/template-to-json.ts <input.ts> <output.json> [exportName]",
-      "",
-      "Loads a TypeScript module, picks one exported value, and writes JSON.stringify to the output path.",
-      "If exportName is omitted: uses default export, or the only non-function export if there is exactly one.",
-      "",
-      "Example:",
-      "  tsx scripts/template-to-json.ts ../templates/source/p2pkh.ts ./p2pkh.json p2pkhTemplate",
-    ].join("\n"),
-  );
-  process.exit(1);
-}
-
-/**
- * Collects runtime export keys whose values are not functions (typical for data/template objects).
- */
-function listDataExportKeys(mod: Record<string, unknown>): string[] {
-  return Object.keys(mod).filter((key) => {
-    if (key === "__esModule") {
-      return false;
-    }
-    const value = mod[key];
-    return typeof value !== "function";
-  });
-}
-
-/**
- * Resolves which export to serialize: explicit name, default, or a single unambiguous data export.
- */
-function resolveExportedValue(
-  mod: Record<string, unknown>,
-  exportName: string | undefined,
-): unknown {
-  if (exportName !== undefined) {
-    if (!(exportName in mod)) {
-      const keys = listDataExportKeys(mod);
-      console.error(
-        `Export "${exportName}" not found. Available data exports: ${keys.length ? keys.join(", ") : "(none)"}`,
-      );
-      process.exit(1);
-    }
-    return mod[exportName];
-  }
-
-  if ("default" in mod && mod.default !== undefined) {
-    return mod.default;
-  }
-
-  const keys = listDataExportKeys(mod);
-  if (keys.length === 1) {
-    return mod[keys[0]!];
-  }
-
-  if (keys.length === 0) {
-    console.error("No suitable exports found (need default or a non-function export).");
-  } else {
-    console.error(
-      `Multiple data exports found; pass exportName. Candidates: ${keys.join(", ")}`,
-    );
-  }
-  process.exit(1);
-}
-
-async function main(): Promise<void> {
-  const args = process.argv.slice(2);
-  if (args.length < 2) {
-    printUsageAndExit();
-  }
-
-  const [inputRel, outputRel, exportName] = args;
-  const inputPath = path.resolve(process.cwd(), inputRel!);
-  const outputPath = path.resolve(process.cwd(), outputRel!);
-
-  /** Dynamic import needs a file URL so Windows paths and ESM resolution behave. */
-  const fileUrl = pathToFileURL(inputPath).href;
-  const mod = (await import(fileUrl)) as Record<string, unknown>;
-  const value = resolveExportedValue(mod, exportName);
-
-  const json = `${JSON.stringify(value, null, 2)}\n`;
-  await fs.mkdir(path.dirname(outputPath), { recursive: true });
-  await fs.writeFile(outputPath, json, "utf8");
-  console.log(`Wrote ${outputPath}`);
-}
-
-await main();
--- a/src/cli/README.md
+++ b/src/cli/README.md
@@ -11,11 +11,11 @@ There are two global commands after install:

 Wallet state lives under **`~/.config/xo-cli/`** (XDG-style), so you can run commands from any directory:

-| Path | Purpose |
-|------|---------|
-| `~/.config/xo-cli/mnemonics/` | Mnemonic files (`mnemonic-*`) |
-| `~/.config/xo-cli/data/` | Engine DB (`xo-wallet.db`) and invitation storage (`xo-invitations.db`) |
-| `~/.config/xo-cli/.wallet` | Last-used mnemonic reference (so `-m` can be omitted) |
+| Path                          | Purpose                                                                 |
+| ----------------------------- | ----------------------------------------------------------------------- |
+| `~/.config/xo-cli/mnemonics/` | Mnemonic files (`mnemonic-*`)                                           |
+| `~/.config/xo-cli/data/`      | Engine DB (`xo-wallet.db`) and invitation storage (`xo-invitations.db`) |
+| `~/.config/xo-cli/.wallet`    | JSON settings (`default-mnemonic`, `currency`)                          |

 **Local to your shell’s current directory:** template JSON paths, invitation JSON you create/import, and any path you pass explicitly (e.g. `-m /abs/path/to/file`).

@@ -41,11 +41,11 @@ npx tsx src/index.ts   # TUI

 ### Environment variables (TUI / `xo-tui`)

-| Variable | Default |
-|----------|---------|
-| `SYNC_SERVER_URL` | `http://localhost:3000` |
-| `DB_PATH` | `~/.config/xo-cli/data` |
-| `DB_FILENAME` | `xo-wallet.db` |
+| Variable                  | Default                                   |
+| ------------------------- | ----------------------------------------- |
+| `SYNC_SERVER_URL`         | `http://localhost:3000`                   |
+| `DB_PATH`                 | `~/.config/xo-cli/data`                   |
+| `DB_FILENAME`             | `xo-wallet.db`                            |
 | `INVITATION_STORAGE_PATH` | `~/.config/xo-cli/data/xo-invitations.db` |

 ## Getting Started
@@ -67,7 +67,10 @@ xo-cli mnemonic list

 ### Wallet Persistence

-The first time you pass `-m <name>`, that reference is saved to `~/.config/xo-cli/.wallet`. Later runs can omit `-m`.
+The first time you pass `-m <name>`, that reference is saved as
+`default-mnemonic` in `~/.config/xo-cli/.wallet`. Later runs can omit `-m`.
+
+`currency` controls the fiat unit used when showing BCH/sats conversions in the TUI.

 Mnemonic resolution order:

@@ -82,11 +85,13 @@ xo-cli resource list

 ## Global Options (`xo-cli`)

-| Flag | Description |
-|------|-------------|
+| Flag                           | Description                                         |
+| ------------------------------ | --------------------------------------------------- |
 | `-m`, `--mnemonic-file <file>` | Mnemonic file (basename, cwd-relative, or absolute) |
-| `-v`, `--verbose` | Verbose output |
-| `-h`, `--help` | Help |
+| `--currency <code>`            | Fiat display currency (e.g. `USD`, `AUD`)            |
+| `-o`, `--output <filename>`    | Output filename (used by `mnemonic create`/`import`) |
+| `-v`, `--verbose`              | Verbose output                                      |
+| `-h`, `--help`                 | Help                                                |

 Advanced: you can pass `--database-path`, `--database-filename`, and `--invitation-storage-path` to override the defaults under `~/.config/xo-cli/data/` (see `src/cli/index.ts`).

@@ -98,6 +103,7 @@ Advanced: you can pass `--database-path`, `--database-filename`, and `--invitati
 xo-cli mnemonic create
 xo-cli mnemonic import <seed words...>
 xo-cli mnemonic list
+xo-cli mnemonic expose <mnemonic-file>
 ```

 ### `template` — Manage Templates
@@ -124,6 +130,16 @@ xo-cli resource unreserve <txhash:vout>
 xo-cli resource unreserve-all
 ```

+### `settings` — Manage Persisted Settings
+
+```bash
+xo-cli settings show
+xo-cli settings get currency
+xo-cli settings get default-mnemonic
+xo-cli settings set currency AUD
+xo-cli settings set default-mnemonic mnemonic-nuclear
+```
+
 ### `receive` — Generate a Receiving Address

 ```bash
@@ -139,20 +155,21 @@ xo-cli invitation sign <invitation-id>
 xo-cli invitation broadcast <invitation-id>
 xo-cli invitation requirements <invitation-id>
 xo-cli invitation import <invitation-file>
+xo-cli invitation inspect <invitation-file>
 xo-cli invitation list
 ```

 **Create / append options:**

-| Flag | Description |
-|------|-------------|
-| `-var-<name> <value>` | Template variable |
-| `--add-input <txhash:vout>` | Inputs (comma-separated) |
-| `--add-output <id>` | Override outputs (omit to auto-discover) |
-| `--auto-inputs` | Auto-select UTXOs |
-| `-role <role>` | Role for variables / bytecode |
-| `--sign` | Auto-sign when complete |
-| `--broadcast` | Auto-broadcast (implies `--sign`) |
+| Flag                        | Description                              |
+| --------------------------- | ---------------------------------------- |
+| `-var-<name> <value>`       | Template variable                        |
+| `--add-input <txhash:vout>` | Inputs (comma-separated)                 |
+| `--add-output <id>`         | Override outputs (omit to auto-discover) |
+| `--auto-inputs`             | Auto-select UTXOs                        |
+| `-role <role>`              | Role for variables / bytecode            |
+| `--sign`                    | Auto-sign when complete                  |
+| `--broadcast`               | Auto-broadcast (implies `--sign`)        |

 Invitation JSON files from `create` / `append` are written to the **current working directory**.

@@ -186,7 +203,7 @@ xo-cli completions fish | source

 ## File Conventions

-| Location | Purpose |
-|----------|---------|
-| `~/.config/xo-cli/` | Global wallet state |
-| `./` (cwd) | Templates, invitation JSON, explicit paths |
+| Location            | Purpose                                    |
+| ------------------- | ------------------------------------------ |
+| `~/.config/xo-cli/` | Global wallet state                        |
+| `./` (cwd)          | Templates, invitation JSON, explicit paths |
--- a/src/cli/arguments.ts
+++ b/src/cli/arguments.ts
@@ -19,24 +19,27 @@ import { z } from "zod";
 * @param args - The CLI args to convert.
 * @returns The key-value object.
 */
-export function convertArgsToObject(args: string[]): { args: string[], options: Record<string, string> } {
+export function convertArgsToObject(args: string[]): {
+  args: string[];
+  options: Record<string, string>;
+} {
  // Map of single-character short flags to their canonical long names
  const shortToFull: Record<string, string> = {
-    'm': 'mnemonicFile',
-    'o': 'output',
-    'v': 'verbose',
-    'h': 'help',
+    m: "mnemonicFile",
+    o: "output",
+    v: "verbose",
+    h: "help",
  };

  // Flags that are always boolean and never consume the next argument as a value.
  // Uses the canonical (expanded) names so the check works after short-form resolution.
  const booleanFlags = new Set<string>([
-    'verbose',
-    'help',
-    'autoInputs',
-    'sign',
-    'broadcast',
-    'install',
+    "verbose",
+    "help",
+    "autoInputs",
+    "sign",
+    "broadcast",
+    "install",
  ]);

  const positionalArgs: string[] = [];
@@ -55,7 +58,9 @@ export function convertArgsToObject(args: string[]): { args: string[], options:
    // - Remove the leading `-`s
    // - Convert kebab-case to camelCase
    // - Expand known short forms to their full names
-    let key = arg.replace(/^-+/, "").replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+    let key = arg
+      .replace(/^-+/, "")
+      .replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
    key = shortToFull[key] ?? key;

    // Known boolean flags never take a value
--- a/src/cli/autocomplete/complete.ts
+++ b/src/cli/autocomplete/complete.ts
@@ -23,13 +23,18 @@
 *   1 - Error (no output, fails silently for shell integration)
 */

-import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { createHash } from "node:crypto";

-import { getDataDir, getMnemonicsDir, getWalletConfigPath } from "../../utils/paths.js";
+import {
+  getDataDir,
+  getMnemonicsDir,
+  getWalletConfigPath,
+} from "../../utils/paths.js";
 import { loadMnemonic } from "../mnemonic.js";
 import { Storage } from "../../services/storage.js";
+import { SettingsService } from "../../services/settings.js";
 import { COMMAND_TREE } from "./completions.js";

 // Lazy-loaded modules (only loaded when needed for dynamic completions)
@@ -56,7 +61,9 @@ async function getEngineModule() {
 */
 function outputCompletions(items: readonly string[], prefix?: string): void {
  const filtered = prefix
-    ? items.filter((item) => item.toLowerCase().startsWith(prefix.toLowerCase()))
+    ? items.filter((item) =>
+        item.toLowerCase().startsWith(prefix.toLowerCase()),
+      )
    : items;

  for (const item of filtered) {
@@ -71,7 +78,9 @@ function outputCompletions(items: readonly string[], prefix?: string): void {
 function listMnemonics(prefix?: string): void {
  try {
    const mnemonicsDir = getMnemonicsDir();
-    const files = readdirSync(mnemonicsDir).filter((f) => f.startsWith("mnemonic-"));
+    const files = readdirSync(mnemonicsDir).filter((f) =>
+      f.startsWith("mnemonic-"),
+    );
    outputCompletions(files, prefix);
  } catch {
    // Silently fail - no completions available
@@ -95,12 +104,8 @@ function listSubcommands(command: string, prefix?: string): void {
 */
 function getCurrentMnemonic(): string | null {
  try {
-    const walletConfigPath = getWalletConfigPath();
-    if (!existsSync(walletConfigPath)) {
-      return null;
-    }
-
-    const mnemonicFile = readFileSync(walletConfigPath, "utf8").trim();
+    const settings = new SettingsService(getWalletConfigPath());
+    const mnemonicFile = settings.getDefaultMnemonic();
    if (!mnemonicFile) {
      return null;
    }
@@ -155,7 +160,13 @@ async function listTemplates(prefix?: string): Promise<void> {
 * Resolves a template by name or ID.
 */
 async function resolveTemplate(
-  engine: Awaited<ReturnType<Awaited<ReturnType<typeof getOfflineEngineModule>>["tryCreateOfflineEngine"]>>,
+  engine: Awaited<
+    ReturnType<
+      Awaited<
+        ReturnType<typeof getOfflineEngineModule>
+      >["tryCreateOfflineEngine"]
+    >
+  >,
  templateQuery: string,
 ) {
  if (!engine) return null;
@@ -165,7 +176,9 @@ async function resolveTemplate(

  // Try exact match on name or ID
  let template = templates.find(
-    (t) => t.name === templateQuery || generateTemplateIdentifier(t) === templateQuery,
+    (t) =>
+      t.name === templateQuery ||
+      generateTemplateIdentifier(t) === templateQuery,
  );

  // Try partial match on name
@@ -181,7 +194,10 @@ async function resolveTemplate(
 /**
 * Lists actions for a specific template.
 */
-async function listActions(templateQuery: string, prefix?: string): Promise<void> {
+async function listActions(
+  templateQuery: string,
+  prefix?: string,
+): Promise<void> {
  const mnemonic = getCurrentMnemonic();
  if (!mnemonic) return;

@@ -210,7 +226,11 @@ async function listActions(templateQuery: string, prefix?: string): Promise<void
 * Lists fields (actions, transactions, outputs, etc.) for a specific template category.
 * Used for completing the 3rd argument of `template inspect <category> <template> <field>`.
 */
-async function listFields(category: string, templateQuery: string, prefix?: string): Promise<void> {
+async function listFields(
+  category: string,
+  templateQuery: string,
+  prefix?: string,
+): Promise<void> {
  const mnemonic = getCurrentMnemonic();
  if (!mnemonic) return;

@@ -300,7 +320,9 @@ async function listResources(prefix?: string): Promise<void> {

  try {
    const utxos = await engine.listUnspentOutputsData();
-    const outpoints = utxos.map((u) => `${u.outpointTransactionHash}:${u.outpointIndex}`);
+    const outpoints = utxos.map(
+      (u) => `${u.outpointTransactionHash}:${u.outpointIndex}`,
+    );
    outputCompletions(outpoints, prefix);
  } finally {
    await engine.stop();
--- a/src/cli/autocomplete/completions.ts
+++ b/src/cli/autocomplete/completions.ts
@@ -19,7 +19,11 @@
 *   xo-cli completions fish --install
 */

-import { existsSync, readFileSync, appendFileSync, writeFileSync } from "node:fs";
+import {
+  existsSync,
+  readFileSync,
+  appendFileSync,
+} from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
@@ -33,6 +37,7 @@ import { homedir } from "node:os";
 * - template.ts: import, list, inspect, set-default
 * - invitation.ts: create, append, sign, broadcast, requirements, import, inspect, list
 * - resource.ts: list, unreserve, unreserve-all
+ * - settings.ts: show, get, set
 */

 /** Subcommands for the mnemonic command */
@@ -40,9 +45,20 @@ const MNEMONIC_SUBS = ["create", "import", "list", "expose"];
 /** Subcommands for the template command */
 const TEMPLATE_SUBS = ["import", "list", "inspect", "set-default"];
 /** Subcommands for the invitation command */
-const INVITATION_SUBS = ["create", "append", "sign", "broadcast", "requirements", "import", "inspect", "list"];
+const INVITATION_SUBS = [
+  "create",
+  "append",
+  "sign",
+  "broadcast",
+  "requirements",
+  "import",
+  "inspect",
+  "list",
+];
 /** Subcommands for the resource command */
 const RESOURCE_SUBS = ["list", "unreserve", "unreserve-all"];
+/** Subcommands for the settings command */
+const SETTINGS_SUBS = ["show", "get", "set"];
 /** Subcommands for the completions command */
 const COMPLETIONS_SUBS = ["bash", "zsh", "fish"];

@@ -52,12 +68,23 @@ export const COMMAND_TREE = {
  invitation: INVITATION_SUBS,
  receive: [],
  resource: RESOURCE_SUBS,
+  settings: SETTINGS_SUBS,
  help: [],
  completions: COMPLETIONS_SUBS,
 } as const;

 /** Global option flags available on every command. */
-const GLOBAL_OPTIONS = ["-h", "--help", "-v", "--verbose", "-m", "--mnemonic-file", "-o", "--output"];
+const GLOBAL_OPTIONS = [
+  "-h",
+  "--help",
+  "-v",
+  "--verbose",
+  "-m",
+  "--mnemonic-file",
+  "--currency",
+  "-o",
+  "--output",
+];

 /**
 * Gets the path to the scripts directory containing shell templates.
@@ -92,13 +119,22 @@ function loadAndProcessTemplate(templateName: string, binName: string): string {
  content = content.replace(/\{\{OPTIONS\}\}/g, options);
  content = content.replace(/\{\{MNEMONIC_SUBS\}\}/g, MNEMONIC_SUBS.join(" "));
  content = content.replace(/\{\{TEMPLATE_SUBS\}\}/g, TEMPLATE_SUBS.join(" "));
-  content = content.replace(/\{\{INVITATION_SUBS\}\}/g, INVITATION_SUBS.join(" "));
+  content = content.replace(
+    /\{\{INVITATION_SUBS\}\}/g,
+    INVITATION_SUBS.join(" "),
+  );
  content = content.replace(/\{\{RESOURCE_SUBS\}\}/g, RESOURCE_SUBS.join(" "));

  // Fish-specific placeholders
  if (templateName.endsWith(".fish")) {
-    content = content.replace(/\{\{TOP_LEVEL_COMMANDS\}\}/g, generateFishTopLevelCommands(binName));
-    content = content.replace(/\{\{STATIC_SUBCOMMANDS\}\}/g, generateFishStaticSubcommands(binName));
+    content = content.replace(
+      /\{\{TOP_LEVEL_COMMANDS\}\}/g,
+      generateFishTopLevelCommands(binName),
+    );
+    content = content.replace(
+      /\{\{STATIC_SUBCOMMANDS\}\}/g,
+      generateFishStaticSubcommands(binName),
+    );
  }

  return content;
@@ -110,7 +146,9 @@ function loadAndProcessTemplate(templateName: string, binName: string): string {
 function generateFishTopLevelCommands(binName: string): string {
  const lines: string[] = [];
  for (const cmd of Object.keys(COMMAND_TREE)) {
-    lines.push(`complete -c ${binName} -n "__fish_use_subcommand" -a "${cmd}" -d "${cmd} command"`);
+    lines.push(
+      `complete -c ${binName} -n "__fish_use_subcommand" -a "${cmd}" -d "${cmd} command"`,
+    );
  }
  return lines.join("\n");
 }
@@ -122,7 +160,9 @@ function generateFishStaticSubcommands(binName: string): string {
  const lines: string[] = [];
  for (const [cmd, subs] of Object.entries(COMMAND_TREE)) {
    for (const sub of subs) {
-      lines.push(`complete -c ${binName} -n "__fish_seen_subcommand_from ${cmd}; and not __fish_seen_subcommand_from ${subs.join(" ")}" -a "${sub}" -d "${cmd} ${sub}"`);
+      lines.push(
+        `complete -c ${binName} -n "__fish_seen_subcommand_from ${cmd}; and not __fish_seen_subcommand_from ${subs.join(" ")}" -a "${sub}" -d "${cmd} ${sub}"`,
+      );
    }
  }
  return lines.join("\n");
@@ -163,7 +203,10 @@ const generators: Record<ShellType, (binName: string) => string> = {
 /**
 * Shell config file paths and eval commands for each shell type.
 */
-const shellConfigs: Record<ShellType, { configFile: string; evalCommand: (binName: string) => string }> = {
+const shellConfigs: Record<
+  ShellType,
+  { configFile: string; evalCommand: (binName: string) => string }
+> = {
  bash: {
    configFile: join(homedir(), ".bashrc"),
    evalCommand: (binName) => `eval "$(${binName} completions bash)"`,
@@ -199,7 +242,8 @@ function installCompletions(shell: ShellType, binName: string): boolean {
  }

  // Append the completion line
-  const newLine = existingContent.endsWith("\n") || existingContent === "" ? "" : "\n";
+  const newLine =
+    existingContent.endsWith("\n") || existingContent === "" ? "" : "\n";
  const completionBlock = `${newLine}\n# ${binName} shell completions\n${evalCommand}\n`;

  appendFileSync(config.configFile, completionBlock);
@@ -227,14 +271,26 @@ export function handleCompletionsCommand(
    console.error(`Usage: ${binName} completions <${supported}> [--install]`);
    console.error("");
    console.error("Examples:");
-    console.error(`  eval "$(${binName} completions bash)"   # Output to stdout (add to ~/.bashrc)`);
-    console.error(`  eval "$(${binName} completions zsh)"    # Output to stdout (add to ~/.zshrc)`);
-    console.error(`  ${binName} completions fish | source    # Output to stdout (add to fish config)`);
+    console.error(
+      `  eval "$(${binName} completions bash)"   # Output to stdout (add to ~/.bashrc)`,
+    );
+    console.error(
+      `  eval "$(${binName} completions zsh)"    # Output to stdout (add to ~/.zshrc)`,
+    );
+    console.error(
+      `  ${binName} completions fish | source    # Output to stdout (add to fish config)`,
+    );
    console.error("");
    console.error("Install directly to shell config:");
-    console.error(`  ${binName} completions bash --install   # Appends to ~/.bashrc`);
-    console.error(`  ${binName} completions zsh --install    # Appends to ~/.zshrc`);
-    console.error(`  ${binName} completions fish --install   # Appends to ~/.config/fish/config.fish`);
+    console.error(
+      `  ${binName} completions bash --install   # Appends to ~/.bashrc`,
+    );
+    console.error(
+      `  ${binName} completions zsh --install    # Appends to ~/.zshrc`,
+    );
+    console.error(
+      `  ${binName} completions fish --install   # Appends to ~/.config/fish/config.fish`,
+    );
    process.exit(1);
  }

--- a/src/cli/autocomplete/offline-engine.ts
+++ b/src/cli/autocomplete/offline-engine.ts
@@ -8,7 +8,11 @@
 * and instead constructs the engine directly with an in-memory blockchain provider.
 */

-import { BlockchainMonitor, Engine, InMemoryBlockchainProvider } from "@xo-cash/engine";
+import {
+  BlockchainMonitor,
+  Engine,
+  InMemoryBlockchainProvider,
+} from "@xo-cash/engine";
 import { createStorageAdapter, State, StorageType } from "@xo-cash/state";
 import { convertMnemonicToSeedBytes } from "@xo-cash/crypto";
 import { binToHex, hash256 } from "@bitauth/libauth";
--- a/src/cli/autocomplete/scripts/bash.sh
+++ b/src/cli/autocomplete/scripts/bash.sh
@@ -1,7 +1,16 @@
-# bash completion for {{BIN_NAME}}
-# Add to ~/.bashrc:  eval "$({{BIN_NAME}} completions bash)"
+# ------------------------------------------------------------------------------
+# Bash completion template for {{BIN_NAME}}
+# ------------------------------------------------------------------------------
+# Installation:
+#   eval "$({{BIN_NAME}} completions bash)"
+#
+# This file is generated from a template. Placeholders (for example `{{OPTIONS}}`)
+# are replaced at build/runtime with concrete command data from the CLI.
+# ------------------------------------------------------------------------------

-# Find xo-complete in the same directory as xo-cli
+# Prefer a globally-installed helper, but fall back to a helper co-located with
+# the CLI binary. This lets completions work in both "installed via PATH" and
+# "single extracted directory" workflows.
 __xo_complete_bin=""
 if command -v xo-complete &>/dev/null; then
  __xo_complete_bin="xo-complete"
@@ -9,16 +18,28 @@ elif command -v {{BIN_NAME}} &>/dev/null; then
  __xo_complete_bin="$(dirname "$(command -v {{BIN_NAME}})")/xo-complete"
 fi

-# Wrapper to call xo-complete helper
+# @description
+# Calls the dynamic completion helper and suppresses helper stderr so the shell
+# completion menu stays clean even when the helper is unavailable or errors.
+# @param "$@" Arguments forwarded to xo-complete.
 __xo_complete() {
  [[ -n "${__xo_complete_bin}" ]] && "${__xo_complete_bin}" "$@" 2>/dev/null
 }

+# @description
+# Main completion dispatcher invoked by bash's `complete -F`.
+# It determines context (command/subcommand/argument position) and then mixes:
+# - static completions (known command words)
+# - dynamic completions (resolved by xo-complete)
+# - filesystem completions (when a subcommand expects file paths)
 _{{FUNC_NAME}}_completions() {
  local cur prev words cword
+  # Populates `cur`, `prev`, `words`, and `cword`.
+  # `_init_completion` is provided by bash-completion.
  _init_completion || return

-  # Handle -m/--mnemonic-file argument (previous word was -m)
+  # If the previous token is `-m/--mnemonic-file`, this argument expects a
+  # mnemonic file alias/path. Ask the helper for mnemonic suggestions.
  if [[ "${prev}" == "-m" || "${prev}" == "--mnemonic-file" ]]; then
    local mnemonics
    mnemonics=$(__xo_complete mnemonics "${cur}")
@@ -30,13 +51,14 @@ _{{FUNC_NAME}}_completions() {
    fi
  fi

-  # If the current word starts with "-", offer option flags
+  # Option context: show global options when the current token starts with `-`.
  if [[ "${cur}" == -* ]]; then
    COMPREPLY=($(compgen -W "{{OPTIONS}}" -- "${cur}"))
    return 0
  fi

-  # Find the command and subcommand positions
+  # Parse command/subcommand from non-option tokens before the current cursor.
+  # We track indices so argument-position logic can be computed later.
  local cmd="" subcmd="" cmd_idx=0 subcmd_idx=0
  for ((i=1; i < cword; i++)); do
    if [[ "${words[i]}" != -* ]]; then
@@ -51,13 +73,13 @@ _{{FUNC_NAME}}_completions() {
    fi
  done

-  # No command yet — offer the top-level commands
+  # No command selected yet: complete top-level commands.
  if [[ -z "${cmd}" ]]; then
    COMPREPLY=($(compgen -W "{{COMMANDS}}" -- "${cur}"))
    return 0
  fi

-  # Handle each command's completion
+  # Command-specific completion rules.
  case "${cmd}" in
    mnemonic)
      if [[ -z "${subcmd}" ]]; then
@@ -69,7 +91,9 @@ _{{FUNC_NAME}}_completions() {
      if [[ -z "${subcmd}" ]]; then
        COMPREPLY=($(compgen -W "{{TEMPLATE_SUBS}}" -- "${cur}"))
      elif [[ "${subcmd}" == "list" || "${subcmd}" == "inspect" ]]; then
-        # template list/inspect <category> <template> [field] - category first, then template, then field
+        # template list/inspect <category> <template> [field]
+        # Position is computed relative to the subcommand token:
+        #   1 => category, 2 => template, 3 => field (inspect only)
        local pos=$((cword - subcmd_idx))
        if [[ $pos -eq 1 ]]; then
          COMPREPLY=($(compgen -W "action transaction output lockingscript variable" -- "${cur}"))
@@ -82,7 +106,7 @@ _{{FUNC_NAME}}_completions() {
            done <<< "${templates}"
          fi
        elif [[ $pos -eq 3 && "${subcmd}" == "inspect" ]]; then
-          # Get the category and template from previous args
+          # Field names depend on both selected category and template.
          local category="${words[subcmd_idx + 1]}"
          local template_arg="${words[subcmd_idx + 2]}"
          local fields
@@ -94,7 +118,8 @@ _{{FUNC_NAME}}_completions() {
          fi
        fi
      elif [[ "${subcmd}" == "set-default" ]]; then
-        # template set-default <template> <output> <role> - template first
+        # template set-default <template> <output> <role>
+        # We only complete the first positional argument (template) here.
        local pos=$((cword - subcmd_idx))
        if [[ $pos -eq 1 ]]; then
          local templates
@@ -114,7 +139,8 @@ _{{FUNC_NAME}}_completions() {
      else
        case "${subcmd}" in
          create)
-            # invitation create <template> <action> - offer templates then actions
+            # invitation create <template> <action>
+            # The available actions depend on the selected template.
            local pos=$((cword - subcmd_idx))
            if [[ $pos -eq 1 ]]; then
              local templates
@@ -136,7 +162,7 @@ _{{FUNC_NAME}}_completions() {
            fi
            ;;
          append|sign|broadcast|requirements|inspect)
-            # These take an invitation ID
+            # These subcommands expect an invitation identifier as first arg.
            local pos=$((cword - subcmd_idx))
            if [[ $pos -eq 1 ]]; then
              local invitations
@@ -149,7 +175,7 @@ _{{FUNC_NAME}}_completions() {
            fi
            ;;
          import)
-            # import takes a file path - use default file completion
+            # File import path: delegate to bash's built-in file completion.
            COMPREPLY=($(compgen -f -- "${cur}"))
            ;;
        esac
@@ -160,7 +186,8 @@ _{{FUNC_NAME}}_completions() {
      if [[ -z "${subcmd}" ]]; then
        COMPREPLY=($(compgen -W "{{RESOURCE_SUBS}}" -- "${cur}"))
      elif [[ "${subcmd}" == "unreserve" ]]; then
-        # resource unreserve <txhash:vout> - offer resources
+        # resource unreserve <txhash:vout>
+        # Suggest known reserved outpoints from the helper.
        local pos=$((cword - subcmd_idx))
        if [[ $pos -eq 1 ]]; then
          local resources
@@ -174,8 +201,20 @@ _{{FUNC_NAME}}_completions() {
      fi
      ;;

+    settings)
+      if [[ -z "${subcmd}" ]]; then
+        COMPREPLY=($(compgen -W "show get set" -- "${cur}"))
+      elif [[ "${subcmd}" == "get" || "${subcmd}" == "set" ]]; then
+        local pos=$((cword - subcmd_idx))
+        if [[ $pos -eq 1 ]]; then
+          COMPREPLY=($(compgen -W "currency default-mnemonic" -- "${cur}"))
+        fi
+      fi
+      ;;
+
    receive)
-      # receive <template> [output] - offer templates
+      # receive <template> [output]
+      # Template is the first positional argument after `receive`.
      local pos=$((cword - cmd_idx))
      if [[ $pos -eq 1 ]]; then
        local templates
@@ -189,6 +228,7 @@ _{{FUNC_NAME}}_completions() {
      ;;

    completions)
+      # Shell target for generating completion scripts.
      if [[ -z "${subcmd}" ]]; then
        COMPREPLY=($(compgen -W "bash zsh fish" -- "${cur}"))
      fi
@@ -196,4 +236,5 @@ _{{FUNC_NAME}}_completions() {
  esac
 }

+# Register the completion function for the CLI binary.
 complete -F _{{FUNC_NAME}}_completions {{BIN_NAME}}
--- a/src/cli/autocomplete/scripts/fish.fish
+++ b/src/cli/autocomplete/scripts/fish.fish
@@ -1,11 +1,21 @@
-# fish completion for {{BIN_NAME}}
-# Add to fish config:  {{BIN_NAME}} completions fish | source
+# ------------------------------------------------------------------------------
+# Fish completion template for {{BIN_NAME}}
+# ------------------------------------------------------------------------------
+# Installation:
+#   {{BIN_NAME}} completions fish | source
+#
+# This file is generated from a template. Placeholders (for example
+# `{{TOP_LEVEL_COMMANDS}}`) are replaced with concrete completion definitions.
+# ------------------------------------------------------------------------------

-# Disable file completions by default
+# Fish offers file completion by default. Disable that globally first so command
+# words are preferred, then selectively re-enable `-F` where paths are expected.
 complete -c {{BIN_NAME}} -f

-# Helper function to get dynamic completions
-# Finds xo-complete in the same directory as {{BIN_NAME}}
+# @description
+# Resolves and calls `xo-complete` for dynamic values (templates, invitations,
+# fields, etc.). We first try PATH, then a helper next to `{{BIN_NAME}}`.
+# @param $argv Arguments forwarded directly to xo-complete.
 function __{{FUNC_NAME}}_complete_dynamic
  set -l xo_complete_bin ""
  if command -q xo-complete
@@ -18,53 +28,70 @@ function __{{FUNC_NAME}}_complete_dynamic
  end
 end

-# Global options
+# Global option flags available across top-level command contexts.
 complete -c {{BIN_NAME}} -s h -d "Show help"
 complete -c {{BIN_NAME}} -l help -d "Show help"
 complete -c {{BIN_NAME}} -s v -d "Verbose output"
 complete -c {{BIN_NAME}} -l verbose -d "Verbose output"
 complete -c {{BIN_NAME}} -s o -d "Output file"
 complete -c {{BIN_NAME}} -l output -d "Output file"
+complete -c {{BIN_NAME}} -l currency -d "Set fiat display currency"

-# Dynamic mnemonic file completion for -m
+# Dynamic completion for `-m/--mnemonic-file`.
 complete -c {{BIN_NAME}} -s m -l mnemonic-file -xa '(__{{FUNC_NAME}}_complete_dynamic mnemonics)'

-# Top-level commands
+# Top-level command registrations inserted by template expansion.
 {{TOP_LEVEL_COMMANDS}}

-# Static sub-commands
+# Static subcommand registrations inserted by template expansion.
 {{STATIC_SUBCOMMANDS}}

-# Dynamic completions
+# ---------------------------------------------------------------------------
+# Dynamic completions by command/subcommand.
+#
+# Fish condition notes:
+# - `__fish_seen_subcommand_from <name>` checks whether `<name>` exists in the
+#   current tokenized command line.
+# - `count (commandline -opc)` returns how many tokens were entered.
+#   We use this to infer positional argument index.
+# ---------------------------------------------------------------------------

-# invitation create: template names
+# invitation create <template> <action>
+# Position 3 => template argument.
 complete -c {{BIN_NAME}} -n "__fish_seen_subcommand_from invitation; and __fish_seen_subcommand_from create; and test (count (commandline -opc)) -eq 3" -xa '(__{{FUNC_NAME}}_complete_dynamic templates)'

-# invitation create: action names (2nd arg)
+# invitation create <template> <action>
+# Position 4 => action argument, filtered by selected template token.
 complete -c {{BIN_NAME}} -n "__fish_seen_subcommand_from invitation; and __fish_seen_subcommand_from create; and test (count (commandline -opc)) -eq 4" -xa '(__{{FUNC_NAME}}_complete_dynamic actions (commandline -opc)[4])'

-# invitation append/sign/broadcast/requirements/inspect: invitation IDs
+# invitation append/sign/broadcast/requirements/inspect <invitation-id>
+# Position 3 => invitation identifier.
 complete -c {{BIN_NAME}} -n "__fish_seen_subcommand_from invitation; and __fish_seen_subcommand_from append; and test (count (commandline -opc)) -eq 3" -xa '(__{{FUNC_NAME}}_complete_dynamic invitations)'
 complete -c {{BIN_NAME}} -n "__fish_seen_subcommand_from invitation; and __fish_seen_subcommand_from sign; and test (count (commandline -opc)) -eq 3" -xa '(__{{FUNC_NAME}}_complete_dynamic invitations)'
 complete -c {{BIN_NAME}} -n "__fish_seen_subcommand_from invitation; and __fish_seen_subcommand_from broadcast; and test (count (commandline -opc)) -eq 3" -xa '(__{{FUNC_NAME}}_complete_dynamic invitations)'
 complete -c {{BIN_NAME}} -n "__fish_seen_subcommand_from invitation; and __fish_seen_subcommand_from requirements; and test (count (commandline -opc)) -eq 3" -xa '(__{{FUNC_NAME}}_complete_dynamic invitations)'
 complete -c {{BIN_NAME}} -n "__fish_seen_subcommand_from invitation; and __fish_seen_subcommand_from inspect; and test (count (commandline -opc)) -eq 3" -xa '(__{{FUNC_NAME}}_complete_dynamic invitations)'

-# invitation import: file completion
+# invitation import <path>
+# Re-enable default filesystem completion for path argument.
 complete -c {{BIN_NAME}} -n "__fish_seen_subcommand_from invitation; and __fish_seen_subcommand_from import" -F

-# template list/inspect: category first (pos 3), then template (pos 4), then field (pos 5 for inspect)
+# template list/inspect <category> <template> [field]
+# Position 3 => category, 4 => template, 5 => field (inspect only).
 complete -c {{BIN_NAME}} -n "__fish_seen_subcommand_from template; and __fish_seen_subcommand_from list; and test (count (commandline -opc)) -eq 3" -xa 'action transaction output lockingscript variable'
 complete -c {{BIN_NAME}} -n "__fish_seen_subcommand_from template; and __fish_seen_subcommand_from list; and test (count (commandline -opc)) -eq 4" -xa '(__{{FUNC_NAME}}_complete_dynamic templates)'
 complete -c {{BIN_NAME}} -n "__fish_seen_subcommand_from template; and __fish_seen_subcommand_from inspect; and test (count (commandline -opc)) -eq 3" -xa 'action transaction output lockingscript variable'
 complete -c {{BIN_NAME}} -n "__fish_seen_subcommand_from template; and __fish_seen_subcommand_from inspect; and test (count (commandline -opc)) -eq 4" -xa '(__{{FUNC_NAME}}_complete_dynamic templates)'
 complete -c {{BIN_NAME}} -n "__fish_seen_subcommand_from template; and __fish_seen_subcommand_from inspect; and test (count (commandline -opc)) -eq 5" -xa '(__{{FUNC_NAME}}_complete_dynamic fields (commandline -opc)[4] (commandline -opc)[5])'

-# template set-default: template first
+# template set-default <template> <output> <role>
+# Position 3 => template argument.
 complete -c {{BIN_NAME}} -n "__fish_seen_subcommand_from template; and __fish_seen_subcommand_from set-default; and test (count (commandline -opc)) -eq 3" -xa '(__{{FUNC_NAME}}_complete_dynamic templates)'

-# resource unreserve: UTXO outpoints
+# resource unreserve <txhash:vout>
+# Position 3 => outpoint to unreserve.
 complete -c {{BIN_NAME}} -n "__fish_seen_subcommand_from resource; and __fish_seen_subcommand_from unreserve; and test (count (commandline -opc)) -eq 3" -xa '(__{{FUNC_NAME}}_complete_dynamic resources)'

-# receive: template names
+# receive <template> [output]
+# Position 2 => template argument.
 complete -c {{BIN_NAME}} -n "__fish_seen_subcommand_from receive; and test (count (commandline -opc)) -eq 2" -xa '(__{{FUNC_NAME}}_complete_dynamic templates)'
--- a/src/cli/autocomplete/scripts/zsh.zsh
+++ b/src/cli/autocomplete/scripts/zsh.zsh
@@ -1,7 +1,15 @@
-# zsh completion for {{BIN_NAME}}
-# Add to ~/.zshrc:  eval "$({{BIN_NAME}} completions zsh)"
+# ------------------------------------------------------------------------------
+# Zsh completion template for {{BIN_NAME}}
+# ------------------------------------------------------------------------------
+# Installation:
+#   eval "$({{BIN_NAME}} completions zsh)"
+#
+# This file is generated from a template. Placeholders (for example
+# `{{MNEMONIC_SUBS}}`) are replaced with concrete command values.
+# ------------------------------------------------------------------------------

-# Find xo-complete in the same directory as xo-cli
+# Prefer a helper on PATH; otherwise fall back to helper next to the CLI binary.
+# This keeps dynamic completion functional in both installed and portable layouts.
 __xo_complete_bin=""
 if (( $+commands[xo-complete] )); then
  __xo_complete_bin="xo-complete"
@@ -9,16 +17,25 @@ elif (( $+commands[{{BIN_NAME}}] )); then
  __xo_complete_bin="${commands[{{BIN_NAME}}]:h}/xo-complete"
 fi

-# Wrapper to call xo-complete helper
+# @description
+# Calls the dynamic helper while silencing helper stderr to avoid noisy
+# completion menus if helper lookup fails.
+# @param "$@" Arguments forwarded to xo-complete.
 __xo_complete() {
  [[ -n "${__xo_complete_bin}" ]] && "${__xo_complete_bin}" "$@" 2>/dev/null
 }

+# @description
+# Main zsh completion dispatcher registered via `compdef`.
+# It resolves command context from `$words`/`$CURRENT` and serves:
+# - static command words via `compadd`
+# - dynamic values from `xo-complete`
+# - filesystem completions where file paths are expected
 _{{FUNC_NAME}}_completions() {
  local -a commands
  commands=({{COMMANDS}})

-  # Handle -m/--mnemonic-file argument (previous word was -m)
+  # If previous token is `-m/--mnemonic-file`, complete mnemonic sources.
  if [[ "${words[CURRENT-1]}" == "-m" || "${words[CURRENT-1]}" == "--mnemonic-file" ]]; then
    local mnemonics
    mnemonics=("${(@f)$(__xo_complete mnemonics "${words[CURRENT]}")}")
@@ -28,13 +45,14 @@ _{{FUNC_NAME}}_completions() {
    fi
  fi

-  # If typing an option flag, complete options
+  # Option context: if current token starts with `-`, complete known options.
  if [[ "${words[${CURRENT}]}" == -* ]]; then
    compadd -- {{OPTIONS}}
    return
  fi

-  # Find the command and subcommand
+  # Find first and second non-option tokens before the cursor.
+  # `cmd_idx` and `subcmd_idx` are used for positional argument calculations.
  local cmd="" subcmd="" cmd_idx=0 subcmd_idx=0
  for ((i=2; i < CURRENT; i++)); do
    if [[ "${words[i]}" != -* ]]; then
@@ -49,13 +67,13 @@ _{{FUNC_NAME}}_completions() {
    fi
  done

-  # No command yet — offer top-level commands
+  # No command token yet: offer top-level commands.
  if [[ -z "${cmd}" ]]; then
    compadd -- ${commands[@]}
    return
  fi

-  # Handle each command's completion
+  # Command-specific completion behavior.
  case "${cmd}" in
    mnemonic)
      if [[ -z "${subcmd}" ]]; then
@@ -67,7 +85,9 @@ _{{FUNC_NAME}}_completions() {
      if [[ -z "${subcmd}" ]]; then
        compadd -- {{TEMPLATE_SUBS}}
      elif [[ "${subcmd}" == "list" || "${subcmd}" == "inspect" ]]; then
-        # template list/inspect <category> <template> [field] - category first, then template, then field
+        # template list/inspect <category> <template> [field]
+        # Relative positions from subcommand:
+        #   1 => category, 2 => template, 3 => field (inspect only)
        local pos=$((CURRENT - subcmd_idx))
        if [[ $pos -eq 1 ]]; then
          compadd -- action transaction output lockingscript variable
@@ -78,7 +98,7 @@ _{{FUNC_NAME}}_completions() {
            compadd -- "${templates[@]}"
          fi
        elif [[ $pos -eq 3 && "${subcmd}" == "inspect" ]]; then
-          # Get the category and template from previous args
+          # Field suggestions depend on selected category and template.
          local category="${words[subcmd_idx + 1]}"
          local template_arg="${words[subcmd_idx + 2]}"
          local fields
@@ -88,7 +108,8 @@ _{{FUNC_NAME}}_completions() {
          fi
        fi
      elif [[ "${subcmd}" == "set-default" ]]; then
-        # template set-default <template> <output> <role> - template first
+        # template set-default <template> <output> <role>
+        # First positional argument is template name.
        local pos=$((CURRENT - subcmd_idx))
        if [[ $pos -eq 1 ]]; then
          local templates
@@ -106,6 +127,8 @@ _{{FUNC_NAME}}_completions() {
      else
        case "${subcmd}" in
          create)
+            # invitation create <template> <action>
+            # Action list is template-specific.
            local pos=$((CURRENT - subcmd_idx))
            if [[ $pos -eq 1 ]]; then
              local templates
@@ -123,6 +146,7 @@ _{{FUNC_NAME}}_completions() {
            fi
            ;;
          append|sign|broadcast|requirements|inspect)
+            # These subcommands take invitation ID as first argument.
            local pos=$((CURRENT - subcmd_idx))
            if [[ $pos -eq 1 ]]; then
              local invitations
@@ -133,6 +157,7 @@ _{{FUNC_NAME}}_completions() {
            fi
            ;;
          import)
+            # invitation import <path>: delegate to zsh file completion.
            _files
            ;;
        esac
@@ -143,6 +168,7 @@ _{{FUNC_NAME}}_completions() {
      if [[ -z "${subcmd}" ]]; then
        compadd -- {{RESOURCE_SUBS}}
      elif [[ "${subcmd}" == "unreserve" ]]; then
+        # resource unreserve <txhash:vout>
        local pos=$((CURRENT - subcmd_idx))
        if [[ $pos -eq 1 ]]; then
          local resources
@@ -154,7 +180,19 @@ _{{FUNC_NAME}}_completions() {
      fi
      ;;

+    settings)
+      if [[ -z "${subcmd}" ]]; then
+        compadd -- show get set
+      elif [[ "${subcmd}" == "get" || "${subcmd}" == "set" ]]; then
+        local pos=$((CURRENT - subcmd_idx))
+        if [[ $pos -eq 1 ]]; then
+          compadd -- currency default-mnemonic
+        fi
+      fi
+      ;;
+
    receive)
+      # receive <template> [output]
      local pos=$((CURRENT - cmd_idx))
      if [[ $pos -eq 1 ]]; then
        local templates
@@ -166,6 +204,7 @@ _{{FUNC_NAME}}_completions() {
      ;;

    completions)
+      # Shell target for completion generation.
      if [[ -z "${subcmd}" ]]; then
        compadd -- bash zsh fish
      fi
@@ -173,4 +212,5 @@ _{{FUNC_NAME}}_completions() {
  esac
 }

+# Register completion function for the executable name.
 compdef _{{FUNC_NAME}}_completions {{BIN_NAME}}
--- a/src/cli/cli-utils.ts
+++ b/src/cli/cli-utils.ts
@@ -1,44 +0,0 @@
-import util from "node:util";
-
-/**
- * Text formatting utilities for the CLI.
- * 
- * Uses ANSI escape codes to format text.
- * 
- * AI Generated links:
- * @see https://en.wikipedia.org/wiki/ANSI_escape_code
- * @see https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_(Select_Graphic_Rendition)_parameters
- * @see https://en.wikipedia.org/wiki/ANSI_escape_code#Colors
- * @see https://en.wikipedia.org/wiki/ANSI_escape_code#Formatting
- * @see https://en.wikipedia.org/wiki/ANSI_escape_code#Cursor_movement
- * @see https://en.wikipedia.org/wiki/ANSI_escape_code#Screen_manipulation
- */
-
-const BOLD = "\x1b[1m";
-export const bold = (text: string) => `${BOLD}${text}${RESET}`;
-
-const DIM = "\x1b[2m";
-export const dim = (text: string) => `${DIM}${text}${RESET}`;
-
-const UNDERLINE = "\x1b[4m";
-export const underline = (text: string) => `${UNDERLINE}${text}${RESET}`;
-
-const INVERSE = "\x1b[7m";
-export const inverse = (text: string) => `${INVERSE}${text}${RESET}`;
-
-const HIDDEN = "\x1b[8m";
-export const hidden = (text: string) => `${HIDDEN}${text}${RESET}`;
-
-const STRIKETHROUGH = "\x1b[9m";
-export const strikethrough = (text: string) => `${STRIKETHROUGH}${text}${RESET}`;
-
-const RESET = "\x1b[0m";
-export const reset = (text: string) => `${RESET}${text}${RESET}`;
-
-export const formatObject = (obj: unknown) => {
-  return util.inspect(obj, {
-    depth: null,
-    colors: true,
-    compact: false
-  });
-};
--- a/src/cli/commands/index.ts
+++ b/src/cli/commands/index.ts
@@ -1,4 +1,5 @@
 export { handleMnemonicCommand, printMnemonicHelp } from "./mnemonic.js";
+export { handleSettingsCommand, printSettingsHelp } from "./settings.js";
 export { handleTemplateCommand, printTemplateHelp } from "./template.js";
 export { handleInvitationCommand, printInvitationHelp } from "./invitation.js";
 export { handleReceiveCommand, printReceiveHelp } from "./receive.js";
--- a/src/cli/commands/invitation.ts
+++ b/src/cli/commands/invitation.ts
@@ -3,7 +3,7 @@ import path from "path";
 import { generateTemplateIdentifier } from "@xo-cash/engine";
 import { binToHex, hexToBin } from "@bitauth/libauth";

-import { bold, dim, formatObject } from "../cli-utils.js";
+import { bold, dim, formatObject } from "../utils.js";
 import type { CommandDependencies, CommandIO } from "./types.js";
 import { CommandError } from "./types.js";
 import type { Invitation } from "../../services/invitation.js";
@@ -42,6 +42,7 @@ function parseVariablesFromOptions(
 ): { variableIdentifier: string; value: string; roleIdentifier?: string }[] {
  const roleIdentifier = options["role"];

+  // Parse the variables from the options by checking if its starts with "var"
  return Object.entries(options)
    .filter(([key]) => key.startsWith("var"))
    .map(([key, value]) => ({
@@ -73,16 +74,20 @@ async function buildAppendParams(
  // --- Inputs ---
  // Accepts comma-separated <txhash>:<vout> pairs via --add-input,
  // OR automatic selection via --auto-inputs.
-  let inputs: { outpointTransactionHash: Uint8Array; outpointIndex: number }[] = [];
+  let inputs: { outpointTransactionHash: Uint8Array; outpointIndex: number }[] =
+    [];

  if (options["autoInputs"] === "true") {
    // Auto-select UTXOs using the greedy algorithm from invitation-flow.
    const suitableResources = await invitation.findSuitableResources();
    const selectable = mapUnspentOutputsToSelectable(suitableResources);

-    const requiredWithFee = (await invitation.getSatsOut().catch(() => 0n)) + DEFAULT_FEE;
+    // Get the required sats out with the default fee
+    const requiredWithFee =
+      (await invitation.getSatsOut().catch(() => 0n)) + DEFAULT_FEE;
    autoSelectGreedyUtxos(selectable, requiredWithFee);

+    // Get the inputs from the selectable UTXOs
    inputs = selectable
      .filter((u) => u.selected)
      .map((u) => ({
@@ -90,21 +95,32 @@ async function buildAppendParams(
        outpointIndex: u.outpointIndex,
      }));

+    // If no inputs are found, print a message and return null
    if (inputs.length === 0) {
      deps.io.err("No suitable UTXOs found for auto-input selection.");
      return null;
    }
    deps.io.verbose(`Auto-selected ${inputs.length} input(s)`);
-  } else if (options["addInput"]) {
+  }
+  // If the add input option is provided, parse the inputs from the options
+  else if (options["addInput"]) {
    inputs = options["addInput"].split(",").map((entry) => {
      const separatorIndex = entry.lastIndexOf(":");
      if (separatorIndex === -1) {
-        throw new Error(`Invalid input format "${entry}". Expected <txhash>:<vout> (e.g. abc123:0)`);
+        throw new Error(
+          `Invalid input format "${entry}". Expected <txhash>:<vout> (e.g. abc123:0)`,
+        );
      }
+
+      // Get the tx hash and vout from the entry
      const txHash = entry.substring(0, separatorIndex);
      const vout = parseInt(entry.substring(separatorIndex + 1), 10);
+
+      // If the tx hash or vout is not a string or isNaN, print a message and throw an error
      if (!txHash || isNaN(vout)) {
-        throw new Error(`Invalid input format "${entry}". Expected <txhash>:<vout> (e.g. abc123:0)`);
+        throw new Error(
+          `Invalid input format "${entry}". Expected <txhash>:<vout> (e.g. abc123:0)`,
+        );
      }
      return {
        outpointTransactionHash: hexToBin(txHash),
@@ -112,7 +128,9 @@ async function buildAppendParams(
      };
    });
  }
-  deps.io.verbose(`Inputs: ${formatObject(inputs.map(i => ({ txHash: binToHex(i.outpointTransactionHash), vout: i.outpointIndex })))}`);
+  deps.io.verbose(
+    `Inputs: ${formatObject(inputs.map((i) => ({ txHash: binToHex(i.outpointTransactionHash), vout: i.outpointIndex })))}`,
+  );

  // --- Outputs ---
  // When --add-output is provided, use those identifiers explicitly.
@@ -135,7 +153,9 @@ async function buildAppendParams(
    }
    outputIdentifiers = [...discovered];
    if (outputIdentifiers.length > 0) {
-      deps.io.verbose(`Auto-discovered output(s) from template: ${outputIdentifiers.join(", ")}`);
+      deps.io.verbose(
+        `Auto-discovered output(s) from template: ${outputIdentifiers.join(", ")}`,
+      );
    }
  }

@@ -151,62 +171,100 @@ async function buildAppendParams(
    }
  }

-  const template = await deps.app.engine.getTemplate(invitation.data.templateIdentifier);
+  // Get the template from the engine
+  const template = await deps.app.engine.getTemplate(
+    invitation.data.templateIdentifier,
+  );

+  // Get the outputs from the template
  const outputs: any[] = await Promise.all(
    outputIdentifiers.map(async (outputId) => {
      // Try variable-based resolution first (e.g. sendSatoshis → recipientLockingscript)
      const providedHex = template
-        ? resolveProvidedLockingBytecodeHex(template, outputId, variableValuesByIdentifier)
+        ? resolveProvidedLockingBytecodeHex(
+            template,
+            outputId,
+            variableValuesByIdentifier,
+          )
        : undefined;

-      const lockingBytecodeHex = providedHex
-        ?? await invitation.generateLockingBytecode(outputId, roleIdentifier);
+      const lockingBytecodeHex =
+        providedHex ??
+        (await invitation.generateLockingBytecode(outputId, roleIdentifier));

-      deps.io.verbose(`Locking bytecode for output "${outputId}": ${lockingBytecodeHex}`);
+      deps.io.verbose(
+        `Locking bytecode for output "${outputId}": ${lockingBytecodeHex}`,
+      );
      return {
        outputIdentifier: outputId,
        lockingBytecode: new Uint8Array(Buffer.from(lockingBytecodeHex, "hex")),
      };
    }),
  );
-  deps.io.verbose(`Outputs: ${formatObject(outputs.map(o => o.outputIdentifier))}`);
+  deps.io.verbose(
+    `Outputs: ${formatObject(outputs.map((o) => o.outputIdentifier))}`,
+  );

  // --- Auto change output ---
  // When inputs are provided, look up each UTXO's value, compute the
  // required sats, and return the excess minus fees back to the user.
  if (inputs.length > 0) {
    const allUtxos = await deps.app.engine.listUnspentOutputsData();
-    const utxoMap = new Map(allUtxos.map(u => [`${u.outpointTransactionHash}:${u.outpointIndex}`, u]));
+    const utxoMap = new Map(
+      allUtxos.map((u) => [
+        `${u.outpointTransactionHash}:${u.outpointIndex}`,
+        u,
+      ]),
+    );

+    // Sum the total input sats
    let totalInputSats = 0n;
+    // Iterate through the inputs and sum the valueSatoshis
    for (const input of inputs) {
+      // Get the tx hash hex
      const txHashHex = binToHex(input.outpointTransactionHash);
+      // Get the utxo from the utxo map
      const utxo = utxoMap.get(`${txHashHex}:${input.outpointIndex}`);
      if (!utxo) {
-        deps.io.err(`UTXO not found: ${txHashHex}:${input.outpointIndex}. Make sure it exists in your wallet.`);
+        // If the utxo is not found, print a message and return null
+        deps.io.err(
+          `UTXO not found: ${txHashHex}:${input.outpointIndex}. Make sure it exists in your wallet.`,
+        );
        return null;
      }
+      // Sum the valueSatoshis
      totalInputSats += BigInt(utxo.valueSatoshis);
    }
    deps.io.verbose(`Total input value: ${totalInputSats} satoshis`);

+    // Get the required sats out
    const requiredSats = await invitation.getSatsOut();
    deps.io.verbose(`Required output value: ${requiredSats} satoshis`);

+    // Get the change amount by subtracting the required sats out from the total input sats and the default fee
    const changeAmount = totalInputSats - requiredSats - DEFAULT_FEE;
-    deps.io.verbose(`Change amount: ${changeAmount} satoshis (fee: ${DEFAULT_FEE})`);
+    deps.io.verbose(
+      `Change amount: ${changeAmount} satoshis (fee: ${DEFAULT_FEE})`,
+    );

+    // If the change amount is less than 0, print a message and return null
    if (changeAmount < 0n) {
-      deps.io.err(`Insufficient funds. Inputs total ${totalInputSats} sats, but need ${requiredSats + DEFAULT_FEE} sats (${requiredSats} required + ${DEFAULT_FEE} fee).`);
+      deps.io.err(
+        `Insufficient funds. Inputs total ${totalInputSats} sats, but need ${requiredSats + DEFAULT_FEE} sats (${requiredSats} required + ${DEFAULT_FEE} fee).`,
+      );
      return null;
    }

+    // If the change amount is greater than or equal to the dust threshold, add the change output
    if (changeAmount >= DUST_THRESHOLD) {
      outputs.push({ valueSatoshis: changeAmount });
      deps.io.out(`Auto-adding change output: ${changeAmount} satoshis`);
-    } else if (changeAmount > 0n) {
-      deps.io.out(`Change ${changeAmount} sats is below dust threshold (${DUST_THRESHOLD} sats), donating to miners as fee.`);
+    }
+    // If the change amount is greater than 0, print a message
+    else if (changeAmount > 0n) {
+      deps.io.out(
+        `Change ${changeAmount} sats is below dust threshold (${DUST_THRESHOLD} sats), donating to miners as fee.`,
+      );
    }
  }

@@ -218,7 +276,7 @@ async function buildAppendParams(
 */
 export const printInvitationHelp = (io: CommandIO): void => {
  io.out(
-`
+    `
 ${bold("Usage:")} xo-cli invitation <sub-command>

 ${bold("Sub-commands:")}
@@ -228,6 +286,7 @@ ${bold("Sub-commands:")}
    - broadcast <invitation-id> ${dim("Broadcast an invitation")}
    - requirements <invitation-id> ${dim("Show requirements for an invitation")}
    - import <invitation-file> ${dim("Import an invitation from a file")}
+    - inspect <invitation-id | invitation-file> ${dim("Inspect an invitation")}
    - list ${dim("List all invitations")}

 ${bold("Create / Append options:")}
@@ -241,7 +300,8 @@ ${bold("Create / Append options:")}

    ${dim("When inputs are provided, a change output is automatically added if the")}
    ${dim("input total exceeds the required amount + fee.")}
-  `);
+  `,
+  );
 };

 /**
@@ -275,289 +335,482 @@ export const handleInvitationCommand = async (
  const subCommand = args[0];
  deps.io.verbose(`Invitation sub-command: ${subCommand}`);

+  // If there was no subcommand provided, print the help message and throw an error
  if (!subCommand) {
    deps.io.verbose("No sub-command provided");
    printInvitationHelp(deps.io);
-    throw new CommandError("invitation.subcommand.missing", "No sub-command provided");
+    throw new CommandError(
+      "invitation.subcommand.missing",
+      "No sub-command provided",
+    );
  }

+  // Switch statement to handle the different subcommands
  switch (subCommand) {
    case "create": {
+      // Get the template query and action identifier from the arguments
      const templateQuery = args[1];
      const actionIdentifier = args[2];
-      deps.io.verbose(`Template query: ${templateQuery}, action identifier: ${actionIdentifier}`);
+      deps.io.verbose(
+        `Template query: ${templateQuery}, action identifier: ${actionIdentifier}`,
+      );

+      // If they didnt provide us with a template query or action identifier, print the help message and throw an error
+      // TODO: Should probably print a specific help message for this command?
      if (!templateQuery || !actionIdentifier) {
        deps.io.verbose("No template file or action identifier provided");
        printInvitationHelp(deps.io);
-        throw new CommandError("invitation.create.arguments_missing", "No template file or action identifier provided");
+        throw new CommandError(
+          "invitation.create.arguments_missing",
+          "No template file or action identifier provided",
+        );
      }

+      // Resolve the template, this will check both filepath and identifier. Because we are flexible here, we will need to generate the identifier again after
      const template = await resolveTemplate(deps, templateQuery);
      const templateIdentifier = generateTemplateIdentifier(template);
+
+      // Create an XOInvitation. We will convert this into our own invitation instance afterwards
      const rawInvitation = await deps.app.engine.createInvitation({
        templateIdentifier,
        actionIdentifier,
      });
      deps.io.verbose(`XOInvitation created: ${formatObject(rawInvitation)}`);

+      // Create our own invitation instance out of the raw XOInvitation. This will also initate the SSE Session
      const invitationInstance = await deps.app.createInvitation(rawInvitation);
-      deps.io.verbose(`Invitation created: ${formatObject(invitationInstance.data)}`);
+      deps.io.verbose(
+        `Invitation created: ${formatObject(invitationInstance.data)}`,
+      );

+      // Read the variables that were passed in via `-var-<name> <value>`
      const variables = parseVariablesFromOptions(options);
      deps.io.verbose(`Variables: ${formatObject(variables)}`);
      if (variables.length > 0) {
        await invitationInstance.addVariables(variables);
      }

+      // Build the parameters for the append call. This will resolve the inputs and outputs for the invitation.
      const params = await buildAppendParams(deps, invitationInstance, options);
      if (!params) {
-        throw new CommandError("invitation.create.append_params_failed", "Failed to build append parameters");
+        throw new CommandError(
+          "invitation.create.append_params_failed",
+          "Failed to build append parameters",
+        );
      }

+      // Append the inputs and outputs to the invitation
      const { inputs, outputs } = params;
      if (inputs.length > 0 || outputs.length > 0) {
        await invitationInstance.append({ inputs, outputs });
      }

+      // Write the invitation to a file in the working directory
+      // TODO: Support the -o flag to specify the output path
      const invitationFilePath = `${deps.paths.workingDir}/inv-${invitationInstance.data.invitationIdentifier}.json`;
      deps.io.verbose(`Invitation file path: ${invitationFilePath}`);
-      writeFileSync(invitationFilePath, encodeExtendedJson(invitationInstance.data, 2));
-      deps.io.out(`Invitation created: ${path.basename(invitationFilePath)} (${invitationInstance.data.invitationIdentifier})`);
+      writeFileSync(
+        invitationFilePath,
+        encodeExtendedJson(invitationInstance.data, 2),
+      );
+      deps.io.out(
+        `Invitation created: ${path.basename(invitationFilePath)} (${invitationInstance.data.invitationIdentifier})`,
+      );

-      const missingRequirements = await invitationInstance.getMissingRequirements();
+      // Get the missing requirements for the invitation. This will tell us if we are missing any variables, inputs, outputs, or roles.
+      const missingRequirements =
+        await invitationInstance.getMissingRequirements();
      const hasMissing =
        (missingRequirements.variables?.length ?? 0) > 0 ||
        (missingRequirements.inputs?.length ?? 0) > 0 ||
        (missingRequirements.outputs?.length ?? 0) > 0 ||
-        (missingRequirements.roles !== undefined && Object.keys(missingRequirements.roles).length > 0);
+        (missingRequirements.roles !== undefined &&
+          Object.keys(missingRequirements.roles).length > 0);

+      // If there are missing requirements, print them out
      if (hasMissing) {
        deps.io.out(`\n${bold("Remaining requirements:")}`);
        deps.io.out(formatObject(missingRequirements));
      } else {
-        const shouldSign = options["sign"] === "true" || options["broadcast"] === "true";
+        // If there are no missing requirements, sign the invitation if the user has requested it
+        const shouldSign =
+          options["sign"] === "true" || options["broadcast"] === "true";
        const shouldBroadcast = options["broadcast"] === "true";

+        // Sign the invitation if the user has requested it
        if (shouldSign) {
          await invitationInstance.sign();
-          deps.io.out(`Invitation signed: ${invitationInstance.data.invitationIdentifier}`);
+          deps.io.out(
+            `Invitation signed: ${invitationInstance.data.invitationIdentifier}`,
+          );
        }

+        // Broadcast the transaction if the user has requested it
        if (shouldBroadcast) {
          const txHash = await invitationInstance.broadcast();
          deps.io.out(`Transaction broadcast: ${bold(txHash)}`);
        } else if (!shouldSign) {
-          deps.io.out(`\n${bold("All requirements satisfied.")} You can now sign with: xo-cli invitation sign ${invitationInstance.data.invitationIdentifier}`);
+          deps.io.out(
+            `\n${bold("All requirements satisfied.")} You can now sign with: xo-cli invitation sign ${invitationInstance.data.invitationIdentifier}`,
+          );
        }
      }
-      return { invitationIdentifier: invitationInstance.data.invitationIdentifier };
+
+      // Return the invitation identifier
+      return {
+        invitationIdentifier: invitationInstance.data.invitationIdentifier,
+      };
    }

    case "append": {
+      // Get the invitation identifier from the arguments
      const invitationIdentifier = args[1];
      deps.io.verbose(`Invitation identifier: ${invitationIdentifier}`);

+      // If they didnt provide us with an invitation identifier, print the help message and throw an error
+      // TODO: Should probably print a specific help message for this command?
      if (!invitationIdentifier) {
        deps.io.verbose("No invitation identifier provided");
        printInvitationHelp(deps.io);
-        throw new CommandError("invitation.append.identifier_missing", "No invitation identifier provided");
+        throw new CommandError(
+          "invitation.append.identifier_missing",
+          "No invitation identifier provided",
+        );
      }

+      // Find the invitation instance in our list of invitations
      const invitation = deps.app.invitations.find(
        (inv) => inv.data.invitationIdentifier === invitationIdentifier,
      );
+
+      // If the invitation is not found, print an error and throw an error
      if (!invitation) {
        deps.io.err(`Invitation not found: ${invitationIdentifier}`);
-        throw new CommandError("invitation.append.not_found", `Invitation not found: ${invitationIdentifier}`);
+        throw new CommandError(
+          "invitation.append.not_found",
+          `Invitation not found: ${invitationIdentifier}`,
+        );
      }
      deps.io.verbose(`Invitation: ${formatObject(invitation.data)}`);

+      // Parse the variables that were passed in via `-var-<name> <value>`
      const variables = parseVariablesFromOptions(options);
      deps.io.verbose(`Variables to append: ${formatObject(variables)}`);
      if (variables.length > 0) {
        await invitation.addVariables(variables);
      }

+      // Build the parameters for the append call. This will resolve the inputs and outputs for the invitation.
      const params = await buildAppendParams(deps, invitation, options);
      if (!params) {
-        throw new CommandError("invitation.append.params_failed", "Failed to build append parameters");
+        throw new CommandError(
+          "invitation.append.params_failed",
+          "Failed to build append parameters",
+        );
      }

+      // If there are no variables, inputs, or outputs, print an error and throw an error
      const { inputs, outputs } = params;
-      if (variables.length === 0 && inputs.length === 0 && outputs.length === 0) {
-        const error = "Nothing to append. Provide variables (-var-<name> <value>), inputs (--add-input <txhash>:<vout>), or outputs (--add-output <identifier>).";
+      if (
+        variables.length === 0 &&
+        inputs.length === 0 &&
+        outputs.length === 0
+      ) {
+        const error =
+          "Nothing to append. Provide variables (-var-<name> <value>), inputs (--add-input <txhash>:<vout>), or outputs (--add-output <identifier>).";
        deps.io.err(error);
        throw new CommandError("invitation.append.empty", error);
      }

+      // Append the inputs and outputs to the invitation
      if (inputs.length > 0 || outputs.length > 0) {
        await invitation.append({ inputs, outputs });
      }
      deps.io.verbose(`Invitation appended: ${formatObject(invitation.data)}`);
      deps.io.out(`Invitation appended: ${invitationIdentifier}`);

+      // Write the invitation to a file in the working directory
+      // TODO: Support the -o flag to specify the output path
      const invitationFilePath = `${deps.paths.workingDir}/inv-${invitation.data.invitationIdentifier}.json`;
      writeFileSync(invitationFilePath, encodeExtendedJson(invitation.data, 2));
-      deps.io.out(`Invitation updated: ${path.basename(invitationFilePath)} (${invitation.data.invitationIdentifier})`);
+      deps.io.out(
+        `Invitation updated: ${path.basename(invitationFilePath)} (${invitation.data.invitationIdentifier})`,
+      );

+      // Get the missing requirements for the invitation. This will tell us if we are missing any variables, inputs, outputs, or roles.
      const missingRequirements = await invitation.getMissingRequirements();
      const hasMissing =
        (missingRequirements.variables?.length ?? 0) > 0 ||
        (missingRequirements.inputs?.length ?? 0) > 0 ||
        (missingRequirements.outputs?.length ?? 0) > 0 ||
-        (missingRequirements.roles !== undefined && Object.keys(missingRequirements.roles).length > 0);
+        (missingRequirements.roles !== undefined &&
+          Object.keys(missingRequirements.roles).length > 0);

+      // If there are missing requirements, print them out
      if (hasMissing) {
        deps.io.out(`\n${bold("Remaining requirements:")}`);
        deps.io.out(formatObject(missingRequirements));
      } else {
-        const shouldSign = options["sign"] === "true" || options["broadcast"] === "true";
+        // If there are no missing requirements, sign the invitation if the user has requested it
+        const shouldSign =
+          options["sign"] === "true" || options["broadcast"] === "true";
        const shouldBroadcast = options["broadcast"] === "true";

+        // Sign the invitation if the user has requested it
        if (shouldSign) {
          await invitation.sign();
          deps.io.out(`Invitation signed: ${invitationIdentifier}`);
        }

+        // Broadcast the transaction if the user has requested it
        if (shouldBroadcast) {
          const txHash = await invitation.broadcast();
          deps.io.out(`Transaction broadcast: ${bold(txHash)}`);
        } else if (!shouldSign) {
-          deps.io.out(`\n${bold("All requirements satisfied.")} You can now sign with: xo-cli invitation sign ${invitationIdentifier}`);
+          deps.io.out(
+            `\n${bold("All requirements satisfied.")} You can now sign with: xo-cli invitation sign ${invitationIdentifier}`,
+          );
        }
      }
      return { invitationIdentifier };
    }

    case "sign": {
+      // Get the invitation identifier from the arguments
      const invitationIdentifier = args[1];
      deps.io.verbose(`Invitation identifier: ${invitationIdentifier}`);
+
+      // If they didnt provide us with an invitation identifier, print the help message and throw an error
+      // TODO: Should probably print a specific help message for this command?
      if (!invitationIdentifier) {
        deps.io.verbose("No invitation identifier provided");
        printInvitationHelp(deps.io);
-        throw new CommandError("invitation.sign.identifier_missing", "No invitation identifier provided");
+        throw new CommandError(
+          "invitation.sign.identifier_missing",
+          "No invitation identifier provided",
+        );
      }

+      // Find the invitation instance in our list of invitations
      const invitation = deps.app.invitations.find(
-        (candidate) => candidate.data.invitationIdentifier === invitationIdentifier,
+        (candidate) =>
+          candidate.data.invitationIdentifier === invitationIdentifier,
      );
+
+      // If the invitation is not found, print an error and throw an error
      if (!invitation) {
        deps.io.err(`Invitation not found: ${invitationIdentifier}`);
-        throw new CommandError("invitation.sign.not_found", `Invitation not found: ${invitationIdentifier}`);
+        throw new CommandError(
+          "invitation.sign.not_found",
+          `Invitation not found: ${invitationIdentifier}`,
+        );
      }
      deps.io.verbose(`Invitation: ${formatObject(invitation.data)}`);

+      // Sign the invitation
      await invitation.sign();
      deps.io.verbose(`Invitation signed: ${formatObject(invitation.data)}`);
      deps.io.out(`Invitation signed: ${invitationIdentifier}`);
+
+      // Return the invitation identifier
      return { invitationIdentifier };
    }
    
    case "broadcast": {
+      // Get the invitation identifier from the arguments
      const invitationIdentifier = args[1];
      deps.io.verbose(`Invitation identifier: ${invitationIdentifier}`);
+
+      // If they didnt provide us with an invitation identifier, print the help message and throw an error
+      // TODO: Should probably print a specific help message for this command?
      if (!invitationIdentifier) {
        deps.io.verbose("No invitation identifier provided");
        printInvitationHelp(deps.io);
-        throw new CommandError("invitation.broadcast.identifier_missing", "No invitation identifier provided");
+        throw new CommandError(
+          "invitation.broadcast.identifier_missing",
+          "No invitation identifier provided",
+        );
      }

+      // Find the invitation instance in our list of invitations
      const invitation = deps.app.invitations.find(
-        (candidate) => candidate.data.invitationIdentifier === invitationIdentifier,
+        (candidate) =>
+          candidate.data.invitationIdentifier === invitationIdentifier,
      );
+
+      // If the invitation is not found, print an error and throw an error
      if (!invitation) {
        deps.io.err(`Invitation not found: ${invitationIdentifier}`);
-        throw new CommandError("invitation.broadcast.not_found", `Invitation not found: ${invitationIdentifier}`);
+        throw new CommandError(
+          "invitation.broadcast.not_found",
+          `Invitation not found: ${invitationIdentifier}`,
+        );
      }
      deps.io.verbose(`Invitation: ${formatObject(invitation.data)}`);

+      // Broadcast the transaction
      const txHash = await invitation.broadcast();
-      deps.io.verbose(`Invitation broadcasted: ${formatObject(invitation.data)}`);
+      deps.io.verbose(
+        `Invitation broadcasted: ${formatObject(invitation.data)}`,
+      );
      deps.io.out(`Transaction broadcast: ${bold(txHash)}`);
+
+      // Return the invitation identifier and transaction hash
      return { invitationIdentifier, txHash };
    }

    case "requirements": {
+      // Get the invitation identifier from the arguments
      const invitationIdentifier = args[1];
      deps.io.verbose(`Invitation identifier: ${invitationIdentifier}`);
+
+      // If they didnt provide us with an invitation identifier, print the help message and throw an error
+      // TODO: Should probably print a specific help message for this command?
      if (!invitationIdentifier) {
        deps.io.verbose("No invitation identifier provided");
        printInvitationHelp(deps.io);
-        throw new CommandError("invitation.requirements.identifier_missing", "No invitation identifier provided");
+        throw new CommandError(
+          "invitation.requirements.identifier_missing",
+          "No invitation identifier provided",
+        );
      }

+      // Find the invitation instance in our list of invitations
      const invitation = deps.app.invitations.find(
-        (candidate) => candidate.data.invitationIdentifier === invitationIdentifier,
+        (candidate) =>
+          candidate.data.invitationIdentifier === invitationIdentifier,
      );
+
+      // If the invitation is not found, print an error and throw an error
      if (!invitation) {
        deps.io.err(`Invitation not found: ${invitationIdentifier}`);
-        throw new CommandError("invitation.requirements.not_found", `Invitation not found: ${invitationIdentifier}`);
+        throw new CommandError(
+          "invitation.requirements.not_found",
+          `Invitation not found: ${invitationIdentifier}`,
+        );
      }
      deps.io.verbose(`Invitation: ${formatObject(invitation.data)}`);

-      const requirements = await deps.app.engine.listRequirements(invitation.data);
+      // List the requirements for the invitation
+      const requirements = await deps.app.engine.listRequirements(
+        invitation.data,
+      );
      deps.io.verbose(`Requirements: ${formatObject(requirements)}`);
      deps.io.out(formatObject(requirements));
+
+      // Return the invitation identifier
      return { invitationIdentifier };
    }

    case "inspect": {
+      // Get the invitation file path from the arguments
      const invitationFilePath = args[1];
+
+      // If they didnt provide us with an invitation file path, print the help message and throw an error
+      // TODO: Should probably print a specific help message for this command?
      deps.io.verbose(`Invitation file path: ${invitationFilePath}`);

+      // Read the invitation file
      if (!invitationFilePath) {
        deps.io.verbose("No invitation file provided");
        printInvitationHelp(deps.io);
-        throw new CommandError("invitation.inspect.file_missing", "No invitation file provided");
+        throw new CommandError(
+          "invitation.inspect.file_missing",
+          "No invitation file provided",
+        );
      }

+      // Read the invitation file (XOInvitation format, can be passed to the engine directly)
      const invitationFile = await readFileSync(invitationFilePath, "utf8");
      deps.io.verbose(`Invitation file: ${invitationFile}`);

+      // Parse the invitation file
      const invitation = JSON.parse(invitationFile);
      deps.io.verbose(`Invitation: ${formatObject(invitation)}`);

+      // Create the invitation instance (NOTE: Not an engine compatible invitation. This is the wrapped format)
      const invitationInstance = await deps.app.createInvitation(invitation);
-      deps.io.verbose(`Invitation created: ${formatObject(invitationInstance.data)}`);
+      deps.io.verbose(
+        `Invitation created: ${formatObject(invitationInstance.data)}`,
+      );

-      const template = await deps.app.engine.getTemplate(invitationInstance.data.templateIdentifier);
+      // Get the template for the invitation
+      const template = await deps.app.engine.getTemplate(
+        invitationInstance.data.templateIdentifier,
+      );

-      const action = template?.actions[invitationInstance.data.actionIdentifier];
+      // Get the action for the invitation
+      const action =
+        template?.actions[invitationInstance.data.actionIdentifier];
      deps.io.verbose(`Action: ${formatObject(action)}`);
+
+      // If the action is not found, print an error and throw an error
      if (!action) {
-        deps.io.err(`Action not found: ${invitationInstance.data.actionIdentifier}`);
-        throw new CommandError("invitation.inspect.action_not_found", `Action not found: ${invitationInstance.data.actionIdentifier}`);
+        deps.io.err(
+          `Action not found: ${invitationInstance.data.actionIdentifier}`,
+        );
+        throw new CommandError(
+          "invitation.inspect.action_not_found",
+          `Action not found: ${invitationInstance.data.actionIdentifier}`,
+        );
      }

+      // Get the status for the invitation
      const status = invitationInstance.status;
      deps.io.verbose(`Status: ${status}`);

-      const entities = Array.from(new Set(invitationInstance.data.commits.map((commit) => commit.entityIdentifier)));
+      // Get the entities for the invitation
+      const entities = Array.from(
+        new Set(
+          invitationInstance.data.commits.map(
+            (commit) => commit.entityIdentifier,
+          ),
+        ),
+      );
      deps.io.verbose(`Entities: ${formatObject(entities)}`);

+      // Get the entities with roles for the invitation
      const entitiesWithRoles = entities.map((entity) => {
        return {
          entityIdentifier: entity,
-          roles: invitationInstance.data.commits.filter((commit) => commit.entityIdentifier === entity).map((commit) => {
-            return [
-              ...(commit.data.inputs?.map((input) => input.roleIdentifier) ?? []),
-              ...(commit.data.outputs?.map((output) => output.roleIdentifier) ?? []),
-              ...(commit.data.variables?.map((variable) => variable.roleIdentifier) ?? []),
-            ];
-          }).flat().filter((role) => role !== undefined)
+          roles: invitationInstance.data.commits
+            .filter((commit) => commit.entityIdentifier === entity)
+            .map((commit) => {
+              return [
+                ...(commit.data.inputs?.map((input) => input.roleIdentifier) ??
+                  []),
+                ...(commit.data.outputs?.map(
+                  (output) => output.roleIdentifier,
+                ) ?? []),
+                ...(commit.data.variables?.map(
+                  (variable) => variable.roleIdentifier,
+                ) ?? []),
+              ];
+            })
+            .flat()
+            .filter((role) => role !== undefined),
        };
      });

-      const inputs = invitationInstance.data.commits.flatMap((commit) => commit.data.inputs ?? []);
+      // Get the inputs for the invitation
+      const inputs = invitationInstance.data.commits.flatMap(
+        (commit) => commit.data.inputs ?? [],
+      );
      deps.io.verbose(`Inputs: ${formatObject(inputs)}`);

-      const outputs = invitationInstance.data.commits.flatMap((commit) => commit.data.outputs ?? []);
+      // Get the outputs for the invitation
+      const outputs = invitationInstance.data.commits.flatMap(
+        (commit) => commit.data.outputs ?? [],
+      );
      deps.io.verbose(`Outputs: ${formatObject(outputs)}`);

-      const variables = invitationInstance.data.commits.flatMap((commit) => commit.data.variables ?? []);
+      // Get the variables for the invitation
+      const variables = invitationInstance.data.commits.flatMap(
+        (commit) => commit.data.variables ?? [],
+      );
      deps.io.verbose(`Variables: ${formatObject(variables)}`);

+      // Return the invitation details
      return {
        templateName: template?.name ?? "Unknown",
        actionIdentifier: invitationInstance.data.actionIdentifier,
@@ -570,29 +823,56 @@ export const handleInvitationCommand = async (
    }

    case "import": {
+      // Get the invitation file path from the arguments
      const invitationFilePath = args[1];
      deps.io.verbose(`Invitation file path: ${invitationFilePath}`);

+      // If they didnt provide us with an invitation file path, print the help message and throw an error
+      // TODO: Should probably print a specific help message for this command?
      if (!invitationFilePath) {
        deps.io.verbose("No invitation file provided");
        printInvitationHelp(deps.io);
-        throw new CommandError("invitation.import.file_missing", "No invitation file provided");
+        throw new CommandError(
+          "invitation.import.file_missing",
+          "No invitation file provided",
+        );
      }

+      // Read the invitation file (XOInvitation format, can be passed to the engine directly)
      const invitationFile = await readFileSync(invitationFilePath, "utf8");
      deps.io.verbose(`Invitation file: ${invitationFile}`);
+
+      // Parse the invitation file
      const invitation = JSON.parse(invitationFile);
      deps.io.verbose(`Invitation: ${formatObject(invitation)}`);
+
+      // "Creates" the invitiation in the engine. This method acts as both creation or import depending on the data that is being passed in
      const xoInvitation = await deps.app.engine.createInvitation(invitation);
+      deps.io.verbose(`XOInvitation: ${formatObject(xoInvitation)}`);
+
+      // Create the invitation instance (NOTE: Not an engine compatible invitation. This is the wrapped format)
      const invitationInstance = await deps.app.createInvitation(xoInvitation);
-      deps.io.verbose(`Invitation created: ${formatObject(invitationInstance.data)}`);
-      return { invitationIdentifier: invitationInstance.data.invitationIdentifier };
+      deps.io.verbose(
+        `Invitation created: ${formatObject(invitationInstance.data)}`,
+      );
+      
+      // Return the invitation identifier
+      return {
+        invitationIdentifier: invitationInstance.data.invitationIdentifier,
+      };
    }

    case "list": {
+      // List all the invitations
      const invitations = await Promise.all(
+        // Iterate over the invitations and compile them into a list of data that we can use to display them with another loop later.
        deps.app.invitations.map(async (invitation) => {
-          const template = await deps.app.engine.getTemplate(invitation.data.templateIdentifier);
+          // Get the template for the invitation
+          const template = await deps.app.engine.getTemplate(
+            invitation.data.templateIdentifier,
+          );
+
+          // Get the role identifier for the invitation
          return {
            invitationIdentifier: invitation.data.invitationIdentifier,
            templateIdentifier: invitation.data.templateIdentifier,
@@ -604,17 +884,27 @@ export const handleInvitationCommand = async (
        }),
      );
      deps.io.verbose(`Invitations: ${formatObject(invitations)}`);
+
+      // Format the invitations into a list of strings that we can display to the user
      const formattedInvitations = invitations.map(
        (invitation) =>
          `${bold(invitation.templateName)} ${dim(invitation.status)} ${dim(invitation.invitationIdentifier)} ${dim(invitation.actionIdentifier)} (${dim(invitation.roleIdentifier)})`,
      );
+
+      // Display the invitations to the user
      deps.io.out(formattedInvitations.join("\n"));
+
+      // Return the number of invitations
      return { count: invitations.length };
    }

    default:
+      // If the sub-command is not found, print an error and throw an error
      deps.io.verbose(`Unknown invitation sub-command: ${subCommand}`);
      printInvitationHelp(deps.io);
-      throw new CommandError("invitation.subcommand.unknown", `Unknown invitation sub-command: ${subCommand}`);
+      throw new CommandError(
+        "invitation.subcommand.unknown",
+        `Unknown invitation sub-command: ${subCommand}`,
+      );
  }
 };
--- a/src/cli/commands/mnemonic.ts
+++ b/src/cli/commands/mnemonic.ts
@@ -1,5 +1,10 @@
-import { bold, dim } from "../cli-utils.js";
-import { listMnemonicFiles, createMnemonicFile, createMnemonicSeed, loadMnemonic } from "../mnemonic.js";
+import { bold, dim } from "../utils.js";
+import {
+  listMnemonicFiles,
+  createMnemonicFile,
+  createMnemonicSeed,
+  loadMnemonic,
+} from "../mnemonic.js";
 import type { BaseCommandDependencies, CommandIO } from "./types.js";
 import { CommandError } from "./types.js";

@@ -8,17 +13,20 @@ import { CommandError } from "./types.js";
 */
 export const printMnemonicHelp = (io: CommandIO): void => {
  io.out(
-`
+    `
 ${bold("Usage:")} xo-cli mnemonic <sub-command>

 ${bold("Sub-commands:")}
    - create <mnemonic-seed> ${dim("Create a new mnemonic file")}
    - list ${dim("List all mnemonic files")}
+    - import <mnemonic-seed> ${dim("Import a mnemonic seed from a file")}
+    - expose <mnemonic-file> ${dim("Expose a mnemonic file")}

 ${bold("Options:")}
    -o --output <output-filename> ${dim("Output filename for the mnemonic file")}
    -h --help ${dim("Show this help message")}
-`);
+`,
+  );
 };

 /**
@@ -33,59 +41,97 @@ export const handleMnemonicCommand = async (
  args: string[],
  options: Record<string, string>,
 ): Promise<{ savedAs?: string; count?: number; mnemonic?: string }> => {
+  // Get the sub-command from the arguments
  const subCommand = args[0];
  const { mnemonicsDir } = deps.paths;

+  // If no sub-command is provided, print the help message and throw an error
  if (!subCommand) {
    deps.io.verbose("No sub-command provided");
    printMnemonicHelp(deps.io);
-    throw new CommandError("mnemonic.subcommand.missing", "No sub-command provided");
+    throw new CommandError(
+      "mnemonic.subcommand.missing",
+      "No sub-command provided",
+    );
  }

+  // Handle the sub-command
  switch (subCommand) {
    case "create": {
+      // Create a new mnemonic seed
      const mnemonicSeed = createMnemonicSeed();
-      const savedAs = createMnemonicFile(mnemonicsDir, mnemonicSeed, options["output"]);

+      // Create a new mnemonic file
+      const savedAs = createMnemonicFile(
+        mnemonicsDir,
+        mnemonicSeed,
+        options["output"],
+      );
+
+      // Display the mnemonic file to the user
      deps.io.out(`Mnemonic file created: ${savedAs} (${mnemonicSeed})`);
      return { savedAs };
    }

    case "import": {
+      // Get the mnemonic seed from the arguments
      const mnemonicSeed = args.slice(1).join(" ");

+      // If no mnemonic seed is provided, print the help message and throw an error
      if (!mnemonicSeed) {
        deps.io.verbose("No mnemonic seed provided");
        printMnemonicHelp(deps.io);
-        throw new CommandError("mnemonic.import.seed_missing", "No mnemonic seed provided");
+        throw new CommandError(
+          "mnemonic.import.seed_missing",
+          "No mnemonic seed provided",
+        );
      }

+      // Create a new mnemonic file
      deps.io.verbose(`Mnemonic seed: ${mnemonicSeed}`);
-      const savedAs = createMnemonicFile(mnemonicsDir, mnemonicSeed, options["output"]);
+      const savedAs = createMnemonicFile(
+        mnemonicsDir,
+        mnemonicSeed,
+        options["output"],
+      );
+
+      // Display the mnemonic file to the user
      deps.io.out(`Mnemonic file created: ${savedAs}`);
      return { savedAs };
    }

    case "list": {
+      // List all the mnemonic files
      const mnemonicFiles = listMnemonicFiles(mnemonicsDir);
-      deps.io.out(mnemonicFiles.join('\n'));
+      deps.io.out(mnemonicFiles.join("\n"));
+
+      // Return the number of mnemonic files
      return { count: mnemonicFiles.length };
    }

    case "expose": {
+      // Get the mnemonic file from the arguments
      const mnemonicFile = args[1];

+      // If no mnemonic file is provided, print the help message and throw an error
      if (!mnemonicFile) {
        deps.io.verbose("No mnemonic file provided");
        printMnemonicHelp(deps.io);
-        throw new CommandError("mnemonic.expose.file_missing", "No mnemonic file provided");
+        throw new CommandError(
+          "mnemonic.expose.file_missing",
+          "No mnemonic file provided",
+        );
      }

+      // Try to load the mnemonic file
      try {
        const mnemonic = loadMnemonic(mnemonicsDir, mnemonicFile);
        deps.io.out(mnemonic);
+
+        // Return the mnemonic
        return { mnemonic };
      } catch (error) {
+        // If the mnemonic file is not found, print an error and throw an error
        throw new CommandError(
          "mnemonic.expose.file_not_found",
          `Mnemonic file not found: ${mnemonicFile}`,
@@ -94,8 +140,12 @@ export const handleMnemonicCommand = async (
    }

    default:
+      // If the sub-command is not found, print an error and throw an error
      deps.io.err(`Unknown sub-command: ${subCommand}`);
      printMnemonicHelp(deps.io);
-      throw new CommandError("mnemonic.subcommand.unknown", `Unknown sub-command: ${subCommand}`);
+      throw new CommandError(
+        "mnemonic.subcommand.unknown",
+        `Unknown sub-command: ${subCommand}`,
+      );
  }
 };
--- a/src/cli/commands/receive.ts
+++ b/src/cli/commands/receive.ts
@@ -1,7 +1,7 @@
 import { generateTemplateIdentifier } from "@xo-cash/engine";
 import { hexToBin, lockingBytecodeToCashAddress } from "@bitauth/libauth";

-import { bold, dim } from "../cli-utils.js";
+import { bold, dim } from "../utils.js";
 import type { CommandDependencies, CommandIO } from "./types.js";
 import { CommandError } from "./types.js";

@@ -12,7 +12,7 @@ import { resolveTemplate } from "../utils.js";
 */
 export const printReceiveHelp = (io: CommandIO): void => {
  io.out(
-`
+    `
 ${bold("Usage:")} xo-cli receive <template-file> <output-identifier> [role-identifier]

 ${bold("Description:")}
@@ -25,7 +25,8 @@ ${bold("Arguments:")}

 ${bold("Options:")}
    -h --help ${dim("Show this help message")}
-`);
+`,
+  );
 };

 /**
@@ -43,16 +44,24 @@ export const handleReceiveCommand = async (
  args: string[],
  _options: Record<string, string>,
 ): Promise<{ address: string }> => {
+  // Get the template query, output identifier, and role identifier from the arguments
  const templateQuery = args[0];
  const outputIdentifier = args[1];
  const roleIdentifier = args[2];

-  deps.io.verbose(`Receive args - template: ${templateQuery}, output: ${outputIdentifier}, role: ${roleIdentifier}`);
+  // Log the receive args
+  deps.io.verbose(
+    `Receive args - template: ${templateQuery}, output: ${outputIdentifier}, role: ${roleIdentifier}`,
+  );

+  // If no template query or output identifier is provided, print the help message and throw an error
  if (!templateQuery || !outputIdentifier) {
    deps.io.verbose("Missing required arguments");
    printReceiveHelp(deps.io);
-    throw new CommandError("receive.arguments.missing", "Missing required arguments");
+    throw new CommandError(
+      "receive.arguments.missing",
+      "Missing required arguments",
+    );
  }

  // Resolve and read the template file
@@ -69,11 +78,17 @@ export const handleReceiveCommand = async (
  deps.io.verbose(`Locking bytecode hex: ${lockingBytecodeHex}`);

  // Convert the locking bytecode to a BCH cash address
-  const result = lockingBytecodeToCashAddress({ bytecode: hexToBin(lockingBytecodeHex), prefix: 'bitcoincash' });
+  const result = lockingBytecodeToCashAddress({
+    bytecode: hexToBin(lockingBytecodeHex),
+    prefix: "bitcoincash",
+  });

-  if (typeof result === 'string') {
+  if (typeof result === "string") {
    deps.io.err(`Failed to encode address: ${result}`);
-    throw new CommandError("receive.address.encode_failed", `Failed to encode address: ${result}`);
+    throw new CommandError(
+      "receive.address.encode_failed",
+      `Failed to encode address: ${result}`,
+    );
  }

  deps.io.out(result.address);
--- a/src/cli/commands/resource.ts
+++ b/src/cli/commands/resource.ts
@@ -1,6 +1,6 @@
 import { hexToBin } from "@bitauth/libauth";

-import { bold, dim } from "../cli-utils.js";
+import { bold, dim } from "../utils.js";
 import type { CommandDependencies, CommandIO } from "./types.js";
 import type { UnspentOutputData } from "@xo-cash/state";
 import { CommandError } from "./types.js";
@@ -10,7 +10,7 @@ import { CommandError } from "./types.js";
 */
 export const printResourceHelp = (io: CommandIO): void => {
  io.out(
-`
+    `
 ${bold("Usage:")} xo-cli resource <sub-command>

 ${bold("Sub-commands:")}
@@ -19,23 +19,38 @@ ${bold("Sub-commands:")}
    - list all              ${dim("List all resources (reserved + unreserved)")}
    - unreserve <txhash:vout> ${dim("Unreserve a specific UTXO")}
    - unreserve-all         ${dim("Unreserve all reserved UTXOs")}
-  `);
+  `,
+  );
 };

 /**
 * Formats a single UTXO for display, optionally including reservation info.
 */
-function formatResource(resource: UnspentOutputData, showReserved = false): string {
-  const outpoint = bold(`${resource.outpointTransactionHash}:${resource.outpointIndex}`);
+function formatResource(
+  resource: UnspentOutputData,
+  showReserved = false,
+): string {
+  // Format the outpoint
+  const outpoint = bold(
+    `${resource.outpointTransactionHash}:${resource.outpointIndex}`,
+  );
+
+  // Format the value
  const value = dim(`${resource.valueSatoshis} sats`);
+
+  // Format the output
  const output = dim(resource.outputIdentifier);
+  
+  // Format the height
  const height = dim(`(height ${resource.minedAtHeight})`);

+  // If the resource is reserved, format the reservation info
  if (showReserved && resource.reservedBy) {
    const inv = dim(`reserved for ${resource.reservedBy}`);
    return `${outpoint} ${value} ${output} ${height} ${inv}`;
  }

+  // Otherwise, format the resource without reservation info
  return `${outpoint} ${value} ${output} ${height}`;
 }

@@ -54,97 +69,166 @@ export const handleResourceCommand = async (
  const subCommand = args[0];
  deps.io.verbose(`Resource sub-command: ${subCommand}`);

+  // If no sub-command is provided, print the help message and throw an error
  if (!subCommand) {
    deps.io.verbose("No sub-command provided");
    printResourceHelp(deps.io);
-    throw new CommandError("resource.subcommand.missing", "No sub-command provided");
+    throw new CommandError(
+      "resource.subcommand.missing",
+      "No sub-command provided",
+    );
  }

+  // Handle the sub-command
  switch (subCommand) {
    case "list": {
+      // Get the qualifier from the arguments - This could be "reserved", "all", or omitted (which defaults to "unreserved")
      const qualifier = args[1];
+
+      // List all the unspent outputs data
      const allResources = await deps.app.engine.listUnspentOutputsData();

      let filtered;
+      // If the qualifier is "reserved", return only the reserved resources
      if (qualifier === "reserved") {
        filtered = allResources.filter((r) => r.reservedBy);
-      } else if (qualifier === "all") {
+      }
+      // If the qualifier is "all", return all the resources
+      else if (qualifier === "all") {
        filtered = allResources;
-      } else {
+      }
+      // If the qualifier is not "reserved" or "all", return only the unreserved resources
+      else {
        filtered = allResources.filter((r) => !r.reservedBy);
      }

+      // If no resources are found, print a message and return 0
      if (filtered.length === 0) {
        deps.io.out(dim("No resources found."));
        return { count: 0 };
      }

+      // Format the resources into a list of strings that we can display to the user
      const showReserved = qualifier === "all" || qualifier === "reserved";
-      const formattedResources = filtered.map((r) => formatResource(r, showReserved));
+      const formattedResources = filtered.map((r) =>
+        formatResource(r, showReserved),
+      );
+
+      // Display the resources to the user
      deps.io.out(formattedResources.join("\n"));
-      deps.io.out(`Total satoshis: ${filtered.reduce((acc, r) => acc + r.valueSatoshis, 0)}`);
+
+      // Display the total satoshis
+      deps.io.out(
+        `Total satoshis: ${filtered.reduce((acc, r) => acc + r.valueSatoshis, 0)}`,
+      );
+
+      // Display the total resources
      deps.io.out(`Total resources: ${filtered.length}`);
      return { count: filtered.length };
    }

    case "unreserve": {
+      // Get the outpoint from the arguments
      const outpointArg = args[1];
+
+      // If no outpoint is provided, print a message and throw an error
      if (!outpointArg) {
        deps.io.err("Please provide a UTXO in <txhash>:<vout> format.");
        printResourceHelp(deps.io);
-        throw new CommandError("resource.unreserve.outpoint_missing", "Please provide a UTXO in <txhash>:<vout> format.");
+        throw new CommandError(
+          "resource.unreserve.outpoint_missing",
+          "Please provide a UTXO in <txhash>:<vout> format.",
+        );
      }

+      // Get the separator index
      const separatorIndex = outpointArg.lastIndexOf(":");
      if (separatorIndex === -1) {
-        deps.io.err(`Invalid format "${outpointArg}". Expected <txhash>:<vout>.`);
-        throw new CommandError("resource.unreserve.outpoint_invalid", `Invalid format "${outpointArg}". Expected <txhash>:<vout>.`);
+        // If the separator index is -1 (not found), print a message and throw an error
+        deps.io.err(
+          `Invalid format "${outpointArg}". Expected <txhash>:<vout>.`,
+        );
+        throw new CommandError(
+          "resource.unreserve.outpoint_invalid",
+          `Invalid format "${outpointArg}". Expected <txhash>:<vout>.`,
+        );
      }

+      // Get the tx hash and vout
      const txHash = outpointArg.substring(0, separatorIndex);
      const vout = parseInt(outpointArg.substring(separatorIndex + 1), 10);
+
+      // If the tx hash or vout is not a string or isNaN, print a message and throw an error
      if (!txHash || isNaN(vout)) {
-        deps.io.err(`Invalid format "${outpointArg}". Expected <txhash>:<vout>.`);
-        throw new CommandError("resource.unreserve.outpoint_invalid", `Invalid format "${outpointArg}". Expected <txhash>:<vout>.`);
+        deps.io.err(
+          `Invalid format "${outpointArg}". Expected <txhash>:<vout>.`,
+        );
+        throw new CommandError(
+          "resource.unreserve.outpoint_invalid",
+          `Invalid format "${outpointArg}". Expected <txhash>:<vout>.`,
+        );
      }

+      // Gather all of our resources
      const allResources = await deps.app.engine.listUnspentOutputsData();
+
+      // Find the target resource
      const target = allResources.find(
        (r) => r.outpointTransactionHash === txHash && r.outpointIndex === vout,
      );

+      // If the target resource is not found, print a message and throw an error
      if (!target) {
        deps.io.err(`UTXO not found: ${txHash}:${vout}`);
-        throw new CommandError("resource.unreserve.utxo_missing", `UTXO not found: ${txHash}:${vout}`);
+        throw new CommandError(
+          "resource.unreserve.utxo_missing",
+          `UTXO not found: ${txHash}:${vout}`,
+        );
      }

+      // If the target resource is not reserved, print a message and return
      if (!target.reservedBy) {
        deps.io.out(dim("UTXO is not reserved. Nothing to do."));
        return {};
      }

+      // Unreserve the resources
      await deps.app.engine.unreserveResources(
        [{ outpointTransactionHash: hexToBin(txHash), outpointIndex: vout }],
-        target.reservedBy ,
+        target.reservedBy,
      );
-      deps.io.out(`Unreserved ${bold(`${txHash}:${vout}`)} (was reserved for ${target.reservedBy})`);
+
+      deps.io.out(
+        `Unreserved ${bold(`${txHash}:${vout}`)} (was reserved for ${target.reservedBy})`,
+      );
+      
+      // TODO: What do I want to return here?
      return {};
    }

    case "unreserve-all": {
+      // Unreserve all the resources
      const count = await deps.app.unreserveAllResources();
+
+      // If no resources are reserved, print a message and return
      if (count === 0) {
        deps.io.out(dim("No reserved resources to unreserve."));
-      } else {
+      }
+      // If some resources were unreserved, print a message and return the count
+      else {
        deps.io.out(`Unreserved ${bold(String(count))} resource(s).`);
      }
+
      return { count };
    }

    default: {
      deps.io.verbose(`Unknown resource sub-command: ${subCommand}`);
      printResourceHelp(deps.io);
-      throw new CommandError("resource.subcommand.unknown", `Unknown resource sub-command: ${subCommand}`);
+      throw new CommandError(
+        "resource.subcommand.unknown",
+        `Unknown resource sub-command: ${subCommand}`,
+      );
    }
  }
 };
--- a/src/cli/commands/settings.ts
+++ b/src/cli/commands/settings.ts
@@ -0,0 +1,131 @@
+import { SettingsService } from "../../services/settings.js";
+import { formatObject } from "../utils.js";
+import type { BaseCommandDependencies, CommandIO } from "./types.js";
+import { CommandError } from "./types.js";
+
+/**
+ * Prints help text for the settings command.
+ */
+export const printSettingsHelp = (io: CommandIO): void => {
+  io.out(`Settings Command Help:
+Commands:
+  settings show
+  settings get <currency|default-mnemonic>
+  settings set <currency|default-mnemonic> <value>
+
+Examples:
+  xo-cli settings show
+  xo-cli settings get currency
+  xo-cli settings set currency AUD
+  xo-cli settings set default-mnemonic mnemonic-main`);
+};
+
+/**
+ * Supported settings keys exposed on the CLI.
+ */
+type SettingsKey = "currency" | "default-mnemonic";
+
+/**
+ * Normalizes user input to one of the supported settings keys.
+ */
+function parseSettingsKey(input: string | undefined): SettingsKey | null {
+  if (!input) {
+    return null;
+  }
+
+  const normalized = input.trim().toLowerCase();
+  if (normalized === "currency") {
+    return "currency";
+  }
+  if (normalized === "default-mnemonic" || normalized === "defaultMnemonic") {
+    return "default-mnemonic";
+  }
+  return null;
+}
+
+/**
+ * Handles `xo-cli settings` commands.
+ *
+ * This command intentionally does not require wallet initialization so users can
+ * configure currency/default mnemonic without passing `-m`.
+ */
+export const handleSettingsCommand = async (
+  deps: BaseCommandDependencies,
+  args: string[],
+  options: Record<string, string>,
+): Promise<Record<string, unknown>> => {
+  const settings = new SettingsService(deps.paths.walletConfigPath);
+
+  // settings show (default if no subcommand)
+  const subCommand = args[0] ?? "show";
+  if (subCommand === "help" || options["help"] === "true") {
+    printSettingsHelp(deps.io);
+    return {};
+  }
+
+  switch (subCommand) {
+    case "show": {
+      const snapshot = settings.getSettings();
+      deps.io.out(formatObject(snapshot));
+      return snapshot;
+    }
+
+    case "get": {
+      const key = parseSettingsKey(args[1]);
+      if (!key) {
+        printSettingsHelp(deps.io);
+        throw new CommandError(
+          "settings.get.key_missing",
+          'Missing or invalid key. Expected "currency" or "default-mnemonic".',
+        );
+      }
+
+      const value =
+        key === "currency"
+          ? settings.getCurrency()
+          : settings.getDefaultMnemonic() ?? "";
+      deps.io.out(value);
+      return { key, value };
+    }
+
+    case "set": {
+      const key = parseSettingsKey(args[1]);
+      if (!key) {
+        printSettingsHelp(deps.io);
+        throw new CommandError(
+          "settings.set.key_missing",
+          'Missing or invalid key. Expected "currency" or "default-mnemonic".',
+        );
+      }
+
+      const rawValue = args.slice(2).join(" ").trim();
+      if (!rawValue) {
+        printSettingsHelp(deps.io);
+        throw new CommandError(
+          "settings.set.value_missing",
+          "Missing value for settings set command.",
+        );
+      }
+
+      if (key === "currency") {
+        settings.setCurrency(rawValue);
+        const currency = settings.getCurrency();
+        deps.io.out(`Updated currency: ${currency}`);
+        return { key, value: currency };
+      }
+
+      settings.setDefaultMnemonic(rawValue);
+      const defaultMnemonic = settings.getDefaultMnemonic() ?? "";
+      deps.io.out(`Updated default-mnemonic: ${defaultMnemonic}`);
+      return { key, value: defaultMnemonic };
+    }
+
+    default: {
+      printSettingsHelp(deps.io);
+      throw new CommandError(
+        "settings.subcommand.unknown",
+        `Unknown settings command: ${subCommand}`,
+      );
+    }
+  }
+};
--- a/src/cli/commands/template.ts
+++ b/src/cli/commands/template.ts
@@ -3,7 +3,7 @@ import path from "path";
 import { generateTemplateIdentifier } from "@xo-cash/engine";
 import type { XOTemplate } from "@xo-cash/types";

-import { bold, dim, formatObject } from "../cli-utils.js";
+import { bold, dim, formatObject } from "../utils.js";
 import { resolveTemplateReferences } from "../../utils/templates.js";
 import type { CommandDependencies, CommandIO } from "./types.js";
 import { CommandError } from "./types.js";
@@ -14,7 +14,7 @@ import { resolveTemplate } from "../utils.js";
 */
 export const printTemplateHelp = (io: CommandIO): void => {
  io.out(
-`
+    `
 ${bold("Usage:")} xo-cli template <sub-command>

 ${bold("Sub-commands:")}
@@ -23,7 +23,8 @@ ${bold("Sub-commands:")}
    - list <category> <identifier> ${dim("List all options of the field type in a template")}
    - inspect <category> <identifier> <field> ${dim("Inspect a field in a template")}
    - set-default <template-file> <output-identifier> <role-identifier> ${dim("Set the default template")}
-  `);
+  `,
+  );
 };

 /**
@@ -36,77 +37,156 @@ export const handleTemplateListCommand = async (
  deps: CommandDependencies,
  args: string[],
 ): Promise<{ count?: number }> => {
+  // Get the template category from the arguments - This could be "action", "transaction", "output", "lockingscript", or "variable"
  const templateCategory = args[0];
  deps.io.verbose(`Template list category: ${templateCategory}`);

+  // If no template category is provided, list all the imported templates
  if (!templateCategory) {
+    // List all the imported templates
    const templates = await deps.app.engine.listImportedTemplates();
-    const formattedTemplates = templates.map((template: XOTemplate) => `${bold(generateTemplateIdentifier(template))} - ${dim(template.name)} ${dim(template.description)}`);
-    deps.io.out(formattedTemplates.join('\n'));
+
+    // Format the templates into a list of strings that we can display to the user
+    const formattedTemplates = templates.map(
+      (template: XOTemplate) =>
+        `${bold(generateTemplateIdentifier(template))} - ${dim(template.name)} ${dim(template.description)}`,
+    );
+
+    // Display the templates to the user
+    deps.io.out(formattedTemplates.join("\n"));
+
+    // Return the number of templates
    return { count: templates.length };
  }

+  // Get the template identifier from the arguments
  const templateIdentifier = args[1];
  deps.io.verbose(`Template identifier: ${templateIdentifier}`);

+  // If no template identifier is provided, print a message and throw an error
  if (!templateIdentifier) {
    deps.io.err("No template identifier provided");
-    throw new CommandError("template.list.identifier_missing", "No template identifier provided");
+    throw new CommandError(
+      "template.list.identifier_missing",
+      "No template identifier provided",
+    );
  }

+  // Get the raw template from the engine
  const rawTemplate = await deps.app.engine.getTemplate(templateIdentifier);
+
+  // If the raw template is not found, print a message and throw an error
  if (!rawTemplate) {
    deps.io.err(`No template found: ${templateIdentifier}`);
-    throw new CommandError("template.list.not_found", `No template found: ${templateIdentifier}`);
+    throw new CommandError(
+      "template.list.not_found",
+      `No template found: ${templateIdentifier}`,
+    );
  }

+  // Resolve the template deeply - Deeply nested objects instead of shallow objects referencing keys at the top level.
+  // Reduces the load of having to call multiple lookups just to get some resolved value like the outputIdentifer that comes from calling an action.
  const template = await resolveTemplateReferences(rawTemplate);
  deps.io.verbose(`Template: ${formatObject(template)}`);

+  // Handle the template category
  switch (templateCategory) {
    case "action": {
+      // Get the actions from the template
      const actions = template.actions;
-      const formattedActions = Object.entries(actions).map(([actionIdentifier, action]) => `${bold(actionIdentifier)} ${dim(action.name)} ${dim(action.description)}`);
-      deps.io.out(formattedActions.join('\n'));
+
+      // Format the actions into a list of strings that we can display to the user
+      const formattedActions = Object.entries(actions).map(
+        ([actionIdentifier, action]) =>
+          `${bold(actionIdentifier)} ${dim(action.name)} ${dim(action.description)}`,
+      );
+
+      // Display the actions to the user
+      deps.io.out(formattedActions.join("\n"));
+
+      // Return the number of actions
      return {};
    }
    case "transaction": {
+      // Get the transactions from the template
      const transactions = template.transactions;
-      const formattedTransactions = Object.entries(transactions).map(([transactionIdentifier, transaction]) => `${bold(transactionIdentifier)} ${dim(transaction.name)} ${dim(transaction.description)}`);
-      deps.io.out(formattedTransactions.join('\n'));
+
+      // Format the transactions into a list of strings that we can display to the user
+      const formattedTransactions = Object.entries(transactions).map(
+        ([transactionIdentifier, transaction]) =>
+          `${bold(transactionIdentifier)} ${dim(transaction.name)} ${dim(transaction.description)}`,
+      );
+
+      // Display the transactions to the user
+      deps.io.out(formattedTransactions.join("\n"));
+
+      // Return the number of transactions
      return {};
    }
    case "output": {
+      // Get the outputs from the template
      const outputs = template.outputs;
-      const formattedOutputs = Object.entries(outputs).map(([outputIdentifier, output]) => `${bold(outputIdentifier)} ${dim(output.name)} ${dim(output.description)}`);
-      deps.io.out(formattedOutputs.join('\n'));
+
+      // Format the outputs into a list of strings that we can display to the user
+      const formattedOutputs = Object.entries(outputs).map(
+        ([outputIdentifier, output]) =>
+          `${bold(outputIdentifier)} ${dim(output.name)} ${dim(output.description)}`,
+      );
+
+      // Display the outputs to the user
+      deps.io.out(formattedOutputs.join("\n"));
+
+      // Return the number of outputs
      return {};
    }
    case "lockingscript": {
+      // Get the lockingscripts from the template
      const lockingscripts = template.lockingScripts;
-      const formattedLockingscripts = Object.entries(lockingscripts).map(([lockingScriptIdentifier, lockingScript]) => `${bold(lockingScriptIdentifier)} ${dim(lockingScript.name)} ${dim(lockingScript.description)}`);
-      deps.io.out(formattedLockingscripts.join('\n'));
+
+      // Format the lockingscripts into a list of strings that we can display to the user
+      const formattedLockingscripts = Object.entries(lockingscripts).map(
+        ([lockingScriptIdentifier, lockingScript]) =>
+          `${bold(lockingScriptIdentifier)} ${dim(lockingScript.name)} ${dim(lockingScript.description)}`,
+      );
+
+      // Display the lockingscripts to the user
+      deps.io.out(formattedLockingscripts.join("\n"));
+
+      // Return the number of lockingscripts
      return {};
    }
    case "variable": {
+      // Get the variables from the template
      const variables = template.variables || {};
-      const formattedVariables = Object.entries(variables).map(([variableIdentifier, variable]) => `${bold(variableIdentifier)} ${dim(variable.name)} ${dim(variable.description)}`);
-      deps.io.out(formattedVariables.join('\n'));
+
+      // Format the variables into a list of strings that we can display to the user
+      const formattedVariables = Object.entries(variables).map(
+        ([variableIdentifier, variable]) =>
+          `${bold(variableIdentifier)} ${dim(variable.name)} ${dim(variable.description)}`,
+      );
+
+      // Display the variables to the user
+      deps.io.out(formattedVariables.join("\n"));
+
+      // Return the number of variables
      return {};
    }
    default: {
      deps.io.verbose(`Unknown template category: ${templateCategory}`);
-      throw new CommandError("template.list.category_unknown", `Unknown template category: ${templateCategory}`);
+      throw new CommandError(
+        "template.list.category_unknown",
+        `Unknown template category: ${templateCategory}`,
+      );
    }
  }
-}
+};

 /**
 * Prints the help message for the template inspect command
 */
 export const printTemplateInspectHelp = (io: CommandIO): void => {
  io.out(
-`
+    `
 ${bold("Usage:")} xo-cli template inspect <category> <identifier> <field>

 ${bold("Arguments:")}
@@ -120,7 +200,8 @@ ${bold("Categories:")}
    - output <output-identifier> ${dim("Inspect an output")}
    - lockingscript <lockingscript-identifier> ${dim("Inspect a lockingscript")}
    - variable <variable-identifier> ${dim("Inspect a variable")}
-  `);
+  `,
+  );
 };

 /**
@@ -133,76 +214,129 @@ export const handleTemplateInspectCommand = async (
  deps: CommandDependencies,
  args: string[],
 ): Promise<Record<string, never>> => {
+  // Get the template category, identifier, and field from the arguments
  const templateCategory = args[0];
  const templateQuery = args[1];
  const templateField = args[2];

-  deps.io.verbose(`Template inspect args - category: ${templateCategory}, identifier: ${templateQuery}, field: ${templateField}`);
+  deps.io.verbose(
+    `Template inspect args - category: ${templateCategory}, identifier: ${templateQuery}, field: ${templateField}`,
+  );

+  // If no template category, identifier, or field is provided, print a message and throw an error
  if (!templateCategory || !templateQuery || !templateField) {
    deps.io.err("No template category, identifier, or field provided");
    printTemplateInspectHelp(deps.io);
-    throw new CommandError("template.inspect.arguments_missing", "No template category, identifier, or field provided");
+    throw new CommandError(
+      "template.inspect.arguments_missing",
+      "No template category, identifier, or field provided",
+    );
  }

+  // Resolve the template
  const originalTemplate = await resolveTemplate(deps, templateQuery);
  deps.io.verbose(`Original Template: ${formatObject(originalTemplate)}`);

+  // Resolve the template references
  const template = await resolveTemplateReferences(originalTemplate);
  deps.io.verbose(`Extended Template: ${formatObject(template)}`);

+  // Handle the template category
  switch (templateCategory) {
    case "action": {
+      // Get the action from the template
      const action = template.actions[templateField];
+
+      // If the action is not found, print a message and throw an error
      if (!action) {
        deps.io.err(`No action found: ${templateField}`);
-        throw new CommandError("template.inspect.action_missing", `No action found: ${templateField}`);
+        throw new CommandError(
+          "template.inspect.action_missing",
+          `No action found: ${templateField}`,
+        );
      }
+
+      // Display the action to the user
      deps.io.out(formatObject(action));
      return {};
    }
    case "transaction": {
+      // Get the transaction from the template
      const transaction = template.transactions?.[templateField];
+
+      // If the transaction is not found, print a message and throw an error
      if (!transaction) {
        deps.io.err(`No transaction found: ${templateField}`);
-        throw new CommandError("template.inspect.transaction_missing", `No transaction found: ${templateField}`);
+        throw new CommandError(
+          "template.inspect.transaction_missing",
+          `No transaction found: ${templateField}`,
+        );
      }
+
+      // Display the transaction to the user
      deps.io.out(formatObject(transaction));
      return {};
    }
    case "output": {
+      // Get the output from the template
      const output = template.outputs[templateField];
+
+      // If the output is not found, print a message and throw an error
      if (!output) {
        deps.io.err(`No output found: ${templateField}`);
-        throw new CommandError("template.inspect.output_missing", `No output found: ${templateField}`);
+        throw new CommandError(
+          "template.inspect.output_missing",
+          `No output found: ${templateField}`,
+        );
      }
+
+      // Display the output to the user
      deps.io.out(formatObject(output));
      return {};
    }
    case "lockingscript": {
+      // Get the lockingscript from the template
      const lockingscript = template.lockingScripts[templateField];
+
+      // If the lockingscript is not found, print a message and throw an error
      if (!lockingscript) {
        deps.io.err(`No lockingscript found: ${templateField}`);
-        throw new CommandError("template.inspect.lockingscript_missing", `No lockingscript found: ${templateField}`);
+        throw new CommandError(
+          "template.inspect.lockingscript_missing",
+          `No lockingscript found: ${templateField}`,
+        );
      }
+
+      // Display the lockingscript to the user
      deps.io.out(formatObject(lockingscript));
      return {};
    }
    case "variable": {
+      // Get the variable from the template
      const variable = template.variables?.[templateField];
+
+      // If the variable is not found, print a message and throw an error
      if (!variable) {
        deps.io.err(`No variable found: ${templateField}`);
-        throw new CommandError("template.inspect.variable_missing", `No variable found: ${templateField}`);
+        throw new CommandError(
+          "template.inspect.variable_missing",
+          `No variable found: ${templateField}`,
+        );
      }
+
+      // Display the variable to the user
      deps.io.out(formatObject(variable));
      return {};
    }
    default: {
      deps.io.verbose(`Unknown template category: ${templateCategory}`);
-      throw new CommandError("template.inspect.category_unknown", `Unknown template category: ${templateCategory}`);
+      throw new CommandError(
+        "template.inspect.category_unknown",
+        `Unknown template category: ${templateCategory}`,
+      );
    }
  }
-}
+};

 /**
 * Handles the template command.
@@ -216,63 +350,110 @@ export const handleTemplateCommand = async (
  args: string[],
  _options: Record<string, string>,
 ): Promise<{ templateFile?: string; count?: number }> => {
+  // Get the sub-command from the arguments
  const subCommand = args[0];

+  // If no sub-command is provided, print a message and throw an error
  if (!subCommand) {
    deps.io.verbose("No sub-command provided");
    printTemplateHelp(deps.io);
-    throw new CommandError("template.subcommand.missing", "No sub-command provided");
+    throw new CommandError(
+      "template.subcommand.missing",
+      "No sub-command provided",
+    );
  }

+  // Handle the sub-command
  switch (subCommand) {
    case "import": {
+      // Get the template file from the arguments
      const templateFile = args[1];
+
+      // If no template file is provided, print a message and throw an error
      deps.io.verbose(`Template file: ${templateFile}`);

      if (!templateFile) {
        deps.io.verbose("No template file provided");
        printTemplateHelp(deps.io);
-        throw new CommandError("template.import.file_missing", "No template file provided");
+        throw new CommandError(
+          "template.import.file_missing",
+          "No template file provided",
+        );
      }

+      // Resolve the template path
      const templatePath = path.resolve(`${process.cwd()}/${templateFile}`);
      deps.io.verbose(`Template path: ${templatePath}`);

+      // If the template file does not exist, print a message and throw an error
      if (!existsSync(templatePath)) {
        deps.io.err(`Template file does not exist: ${templatePath}`);
        printTemplateHelp(deps.io);
-        throw new CommandError("template.import.file_not_found", `Template file does not exist: ${templatePath}`);
+        throw new CommandError(
+          "template.import.file_not_found",
+          `Template file does not exist: ${templatePath}`,
+        );
      }

+      // Read the template file
      const template = await readFileSync(templatePath, "utf8");
-
      deps.io.verbose(`Importing template: ${templateFile}`);
+
+      // Import the template
      await deps.app.engine.importTemplate(template);
      deps.io.verbose(`Template imported: ${templateFile}`);
+
+      // Return the template file
      return { templateFile };
    }
    case "list": {
+      // Handle the template list command, We offload here as it has lots of arguments and is quite long
      return handleTemplateListCommand(deps, args.slice(1));
    }
    case "inspect": {
+      // Handle the template inspect command, We offload here as it has lots of arguments and is quite long
      return handleTemplateInspectCommand(deps, args.slice(1));
    }
    case "set-default": {
+      // Get the template file, output identifier, and role identifier from the arguments
      const templateFile = args[1];
      const outputIdentifier = args[2];
      const roleIdentifier = args[3];
+
+      // If no template file, output identifier, or role identifier is provided, print a message and throw an error
      if (!templateFile || !outputIdentifier || !roleIdentifier) {
-        deps.io.verbose("No template file, output identifier, or role identifier provided");
+        deps.io.verbose(
+          "No template file, output identifier, or role identifier provided",
+        );
        printTemplateHelp(deps.io);
-        throw new CommandError("template.default.arguments_missing", "No template file, output identifier, or role identifier provided");
+        throw new CommandError(
+          "template.default.arguments_missing",
+          "No template file, output identifier, or role identifier provided",
+        );
      }
-      deps.io.verbose(`Template file: ${templateFile}, output identifier: ${outputIdentifier}, role identifier: ${roleIdentifier}`);
-      await deps.app.engine.setDefaultLockingParameters(templateFile, outputIdentifier, roleIdentifier);
+
+      // Set the default locking parameters
+      deps.io.verbose(
+        `Template file: ${templateFile}, output identifier: ${outputIdentifier}, role identifier: ${roleIdentifier}`,
+      );
+
+      // Set the default locking parameters
+      await deps.app.engine.setDefaultLockingParameters(
+        templateFile,
+        outputIdentifier,
+        roleIdentifier,
+      );
+
+      // Return an empty object
      return {};
    }
    default:
+      // If the sub-command is not found, print a message and throw an error
      deps.io.verbose(`Unknown template sub-command: ${subCommand}`);
      printTemplateHelp(deps.io);
-      throw new CommandError("template.subcommand.unknown", `Unknown template sub-command: ${subCommand}`);
+      throw new CommandError(
+        "template.subcommand.unknown",
+        `Unknown template sub-command: ${subCommand}`,
+      );
  }
 };
--- a/src/cli/index.ts
+++ b/src/cli/index.ts
@@ -35,14 +35,18 @@
 * -m --mnemonic-file <mnemonic-file>
 */

-import { existsSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";

 import { AppService } from "../services/app.js";
+import { SettingsService } from "../services/settings.js";
 import { convertArgsToObject } from "./arguments.js";
-import { bold, dim, formatObject } from "./cli-utils.js";
+import { bold, dim, formatObject } from "./utils.js";
 import { listGlobalMnemonicFiles, loadMnemonic } from "./mnemonic.js";
-import { getDataDir, getMnemonicsDir, getWalletConfigPath } from "../utils/paths.js";
+import {
+  getDataDir,
+  getMnemonicsDir,
+  getWalletConfigPath,
+} from "../utils/paths.js";

 import {
  type CommandDependencies,
@@ -50,6 +54,7 @@ import {
  type CommandPaths,
  CommandError,
  handleMnemonicCommand,
+  handleSettingsCommand,
  handleTemplateCommand,
  handleInvitationCommand,
  handleReceiveCommand,
@@ -111,6 +116,7 @@ async function main(): Promise<void> {
    walletConfigPath: getWalletConfigPath(),
    workingDir: process.cwd(),
  };
+  const settings = new SettingsService(paths.walletConfigPath);

  // Early handling for completions command
  if (command === "completions") {
@@ -130,21 +136,45 @@ async function main(): Promise<void> {
    }
  }

-  // Resolve mnemonic file: explicit flag > persisted config > error.
+  if (command === "settings") {
+    try {
+      await handleSettingsCommand({ io, paths }, subArgs, options);
+      process.exit(0);
+    } catch (error) {
+      if (error instanceof CommandError) {
+        process.exit(error.code);
+      }
+      throw error;
+    }
+  }
+
+  // Resolve mnemonic file: explicit flag > persisted settings > error.
  let mnemonicFile = options["mnemonicFile"];
-  if (!mnemonicFile && existsSync(paths.walletConfigPath)) {
-    mnemonicFile = readFileSync(paths.walletConfigPath, "utf8").trim();
+  let didUsePersistedMnemonic = false;
+  if (!mnemonicFile) {
+    mnemonicFile = settings.getDefaultMnemonic();
+    didUsePersistedMnemonic = Boolean(mnemonicFile);
+  }
+  if (didUsePersistedMnemonic && mnemonicFile) {
    io.verbose(`Using persisted wallet: ${mnemonicFile}`);
  }
  if (!mnemonicFile) {
    io.err("No mnemonic file provided");
-    io.out(`You can create a mnemonic file with the following command: xo-cli mnemonic create <mnemonic-seed> or use one of the following files: \n${listGlobalMnemonicFiles().join("\n")}`);
-    io.out(`\nTip: pass -m <file> once and it will be remembered in ${paths.walletConfigPath}`);
+    io.out(
+      `You can create a mnemonic file with the following command: xo-cli mnemonic create <mnemonic-seed> or use one of the following files: \n${listGlobalMnemonicFiles().join("\n")}`,
+    );
+    io.out(
+      `\nTip: pass -m <file> once and it will be remembered in ${paths.walletConfigPath}`,
+    );
    process.exit(1);
  }

  // Persist the choice so subsequent commands can omit -m.
-  writeFileSync(paths.walletConfigPath, mnemonicFile);
+  settings.setDefaultMnemonic(mnemonicFile);
+  if (options["currency"]) {
+    settings.setCurrency(options["currency"]);
+    io.verbose(`Using configured currency: ${settings.getCurrency()}`);
+  }

  const mnemonic = loadMnemonic(paths.mnemonicsDir, mnemonicFile);
  io.verbose(`Loaded mnemonic from file: ${mnemonicFile} ${mnemonic}`);
@@ -158,8 +188,9 @@ async function main(): Promise<void> {
      databaseFilename: options["databaseFilename"] ?? "xo-wallet.db",
    },
    invitationStoragePath:
-      options["invitationStoragePath"] ?? join(paths.dataDir, "xo-invitations.db"),
-  });
+      options["invitationStoragePath"] ??
+      join(paths.dataDir, "xo-invitations.db"),
+  }, settings);
  io.verbose("App instance created");

  // Start the app
@@ -179,23 +210,42 @@ async function main(): Promise<void> {
    let result: unknown;
    switch (command) {
      case "template":
-        result = await handleTemplateCommand(commandDependencies, subArgs, options);
+        result = await handleTemplateCommand(
+          commandDependencies,
+          subArgs,
+          options,
+        );
        break;
      case "invitation":
-        result = await handleInvitationCommand(commandDependencies, subArgs, options);
+        result = await handleInvitationCommand(
+          commandDependencies,
+          subArgs,
+          options,
+        );
        break;
      case "receive":
-        result = await handleReceiveCommand(commandDependencies, subArgs, options);
+        result = await handleReceiveCommand(
+          commandDependencies,
+          subArgs,
+          options,
+        );
        break;
      case "resource":
-        result = await handleResourceCommand(commandDependencies, subArgs, options);
+        result = await handleResourceCommand(
+          commandDependencies,
+          subArgs,
+          options,
+        );
        break;
      case "help":
        result = await handleHelpCommand(commandDependencies, subArgs, options);
        break;
      default:
        io.err(`Unknown command: ${command}`);
-        throw new CommandError("cli.command.unknown", `Unknown command: ${command}`);
+        throw new CommandError(
+          "cli.command.unknown",
+          `Unknown command: ${command}`,
+        );
    }

    // console.log(result);
@@ -217,7 +267,7 @@ const handleHelpCommand = async (
  _options: Record<string, string>,
 ): Promise<Record<string, never>> => {
  deps.io.out(
-`${bold("XO-CLI Help:")}
+    `${bold("XO-CLI Help:")}

 ${bold("Usage:")} xo-cli <command> [options]

@@ -227,12 +277,15 @@ Commands:
  invitation  ${dim("Manage invitations")}
  receive     ${dim("Generate a single-use receiving address")}
  resource    ${dim("Manage resources")}
+  settings    ${dim("Manage persisted wallet settings")}
  completions ${dim("Generate shell completion scripts (bash, zsh, fish)")}
+  help        ${dim("Show this help message")}

 Options:
  -h, --help    ${dim("Show this help message")}
  -m, --mnemonic-file <mnemonic-file>  ${dim("Use a specific mnemonic file")}
-  -v, --verbose   ${dim("Show verbose output")}`
+  --currency <currency-code>  ${dim("Set fiat display currency (e.g. USD, AUD)")}
+  -v, --verbose   ${dim("Show verbose output")}`,
  );
  return {};
 };
--- a/src/cli/mnemonic.ts
+++ b/src/cli/mnemonic.ts
@@ -28,9 +28,11 @@ export const createMnemonicFile = (

  let fileName = outputFilename;
  if (!fileName) {
-    const firstWord = mnemonic.split(' ')[0]?.toLowerCase();
+    const firstWord = mnemonic.split(" ")[0]?.toLowerCase();
    if (!firstWord) {
-      throw new Error("Failed to create mnemonic file: Unable to extract first word from the mnemonic");
+      throw new Error(
+        "Failed to create mnemonic file: Unable to extract first word from the mnemonic",
+      );
    }
    fileName = `mnemonic-${firstWord}`;
  }
@@ -55,20 +57,24 @@ export const resolveMnemonicFilePath = (
  mnemonicsDir: string,
  mnemonicRef: string,
 ): string => {
+  // Try to resolve the mnemonic file as an absolute path
  if (isAbsolute(mnemonicRef) && existsSync(mnemonicRef)) {
    return mnemonicRef;
  }

+  // Try to resolve the mnemonic file relative to the current working directory
  const relativeToCwd = resolve(process.cwd(), mnemonicRef);
  if (existsSync(relativeToCwd)) {
    return relativeToCwd;
  }

+  // Try to resolve the mnemonic file in the mnemonics directory
  const inMnemonics = join(mnemonicsDir, basename(mnemonicRef));
  if (existsSync(inMnemonics)) {
    return inMnemonics;
  }

+  // If the mnemonic file is not found, throw an error
  throw new Error(
    `Mnemonic file not found: ${mnemonicRef}. Run "xo-cli mnemonic list" to see available files.`,
  );
@@ -80,17 +86,30 @@ export const resolveMnemonicFilePath = (
 * @param mnemonicFile - The filename of the mnemonic file
 * @returns The mnemonic seed
 */
-export const loadMnemonic = (mnemonicsDir: string, mnemonicFile: string): string => {
+export const loadMnemonic = (
+  mnemonicsDir: string,
+  mnemonicFile: string,
+): string => {
+  // Resolve the mnemonic file path
  const resolvedPath = resolveMnemonicFilePath(mnemonicsDir, mnemonicFile);
-  const mnemonicUrl = BCHMnemonicURL.fromURL(readFileSync(resolvedPath, "utf8"));
+
+  // Read the mnemonic file
+  const mnemonicUrl = BCHMnemonicURL.fromURL(
+    readFileSync(resolvedPath, "utf8"),
+  );
+
+  // Get the entropy from the mnemonic url
  const { entropy } = mnemonicUrl.toObject();

+  // Encode the entropy to a mnemonic
  const mnemonic = encodeBip39Mnemonic(entropy);

+  // If the mnemonic is not a string, throw an error
  if (typeof mnemonic === "string") {
    throw new Error(`Failed to convert entropy to mnemonic: ${mnemonic}`);
  }

+  // Return the mnemonic phrase
  return mnemonic.phrase;
 };

@@ -100,9 +119,12 @@ export const loadMnemonic = (mnemonicsDir: string, mnemonicFile: string): string
 * @returns Basenames suitable for `-m <name>`
 */
 export const listMnemonicFiles = (mnemonicsDir: string): string[] => {
+  // List the mnemonic files in the given directory
  const filenames = readdirSync(mnemonicsDir).filter((f: string) =>
    f.startsWith("mnemonic-"),
  );
+
+  // Return the mnemonic files
  return filenames;
 };

@@ -112,5 +134,6 @@ export const listMnemonicFiles = (mnemonicsDir: string): string[] => {
 * @returns Basenames suitable for `-m <name>`
 */
 export const listGlobalMnemonicFiles = (): string[] => {
+  // List the mnemonic files in the global mnemonics directory
  return listMnemonicFiles(getGlobalMnemonicsDir());
 };
--- a/src/cli/utils.ts
+++ b/src/cli/utils.ts
@@ -1,7 +1,10 @@
+import util from "node:util";
+
 import type { XOTemplate } from "@xo-cash/types";
+import { generateTemplateIdentifier } from "@xo-cash/engine";
+
 import type { CommandDependencies } from "./commands/types.js";
 import { CommandError } from "./commands/types.js";
-import { generateTemplateIdentifier } from "@xo-cash/engine";

 /**
 * Iterate through the templates, trying to match the id or the name with the given input.
@@ -16,33 +19,96 @@ import { generateTemplateIdentifier } from "@xo-cash/engine";
 * @throws CommandError if no template is found.
 * @throws CommandError if multiple templates are found.
 */
-export const resolveTemplate = async (deps: CommandDependencies, query: string): Promise<XOTemplate> => {
+export const resolveTemplate = async (
+  deps: CommandDependencies,
+  query: string,
+): Promise<XOTemplate> => {
+  // Gather all of our imported templates
  const templates = await deps.app.engine.listImportedTemplates();

+  // Create a set to store the matches
  const matches = new Set<XOTemplate>();

+  // Iterate through the templates and check if the identifier matches the query
  for (const template of templates) {
    if (generateTemplateIdentifier(template) === query) {
+      // Return early if we got a match since identifiers are always unique by content
      return template;
    }
  }

+  // Iterate through the templates and check if the name matches the query
  for (const template of templates) {
    if (template.name === query) {
      matches.add(template);
    }
  }

+  // If there are multiple matches, throw an error
  if (matches.size > 1) {
    throw new CommandError(
      "template.resolve.multiple_matches",
-      `Multiple templates found for "${query}": ${Array.from(matches).map(template => `${template.name} (${generateTemplateIdentifier(template)})`).join(", ")}`,
+      `Multiple templates found for "${query}": ${Array.from(matches)
+        .map(
+          (template) =>
+            `${template.name} (${generateTemplateIdentifier(template)})`,
+        )
+        .join(", ")}`,
    );
  }

+  // If there is one match, return the match
  if (matches.size === 1) {
    return matches.values().next().value!;
  }

-  throw new CommandError("template.resolve.not_found", `Template not found: ${query}`);
-}
+  // If there are no matches, throw an error
+  throw new CommandError(
+    "template.resolve.not_found",
+    `Template not found: ${query}`,
+  );
+};
+
+/**
+ * Text formatting utilities for the CLI.
+ *
+ * Uses ANSI escape codes to format text.
+ *
+ * AI Generated links:
+ * @see https://en.wikipedia.org/wiki/ANSI_escape_code
+ * @see https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_(Select_Graphic_Rendition)_parameters
+ * @see https://en.wikipedia.org/wiki/ANSI_escape_code#Colors
+ * @see https://en.wikipedia.org/wiki/ANSI_escape_code#Formatting
+ * @see https://en.wikipedia.org/wiki/ANSI_escape_code#Cursor_movement
+ * @see https://en.wikipedia.org/wiki/ANSI_escape_code#Screen_manipulation
+ */
+
+const BOLD = "\x1b[1m";
+export const bold = (text: string) => `${BOLD}${text}${RESET}`;
+
+const DIM = "\x1b[2m";
+export const dim = (text: string) => `${DIM}${text}${RESET}`;
+
+const UNDERLINE = "\x1b[4m";
+export const underline = (text: string) => `${UNDERLINE}${text}${RESET}`;
+
+const INVERSE = "\x1b[7m";
+export const inverse = (text: string) => `${INVERSE}${text}${RESET}`;
+
+const HIDDEN = "\x1b[8m";
+export const hidden = (text: string) => `${HIDDEN}${text}${RESET}`;
+
+const STRIKETHROUGH = "\x1b[9m";
+export const strikethrough = (text: string) =>
+  `${STRIKETHROUGH}${text}${RESET}`;
+
+const RESET = "\x1b[0m";
+export const reset = (text: string) => `${RESET}${text}${RESET}`;
+
+export const formatObject = (obj: unknown) => {
+  return util.inspect(obj, {
+    depth: null,
+    colors: true,
+    compact: false,
+  });
+};
--- a/src/services/app.ts
+++ b/src/services/app.ts
@@ -11,6 +11,8 @@ import { BaseStorage, Storage } from "./storage.js";
 import { SyncServer } from "../utils/sync-server.js";
 import { HistoryService } from "./history.js";
 import { type BlockchainService, ElectrumService } from "./electrum.js";
+import { RatesService } from "./rates.js";
+import { SettingsService } from "./settings.js";

 import { EventEmitter } from "../utils/event-emitter.js";

@@ -18,6 +20,7 @@ import { EventEmitter } from "../utils/event-emitter.js";
 import { createHash } from "crypto";
 import { p2pkhTemplate } from "@xo-cash/templates";
 import { hexToBin } from "@bitauth/libauth";
+import { parseTemplate } from "@xo-cash/engine";

 export type AppEventMap = {
  "invitation-added": Invitation;
@@ -46,6 +49,8 @@ export class AppService extends EventEmitter<AppEventMap> {
  public config: AppConfig;
  public history: HistoryService;
  public electrum: BlockchainService;
+  public rates: RatesService;
+  public settings: SettingsService;

  public invitations: Invitation[] = [];
  private invitationEventCleanup = new Map<
@@ -56,7 +61,11 @@ export class AppService extends EventEmitter<AppEventMap> {
    }
  >();

-  static async create(seed: string, config: AppConfig): Promise<AppService> {
+  static async create(
+    seed: string,
+    config: AppConfig,
+    settings: SettingsService = new SettingsService(),
+  ): Promise<AppService> {
    // Because of a bug that lets wallets read the unspents of other wallets, we are going to manually namespace the storage paths for the app.
    // We are going to do this by computing a hash of the seed and prefixing the storage paths with it.
    const seedHash = createHash("sha256").update(seed).digest("hex");
@@ -74,14 +83,39 @@ export class AppService extends EventEmitter<AppEventMap> {
    // Import the default P2PKH template
    const { templateIdentifier } = await engine.importTemplate(p2pkhTemplate);

-    engine.subscribeToLockingBytecodesForTemplate(templateIdentifier).catch(err => console.error(`Error subscribing to locking bytecodes for template ${templateIdentifier}: ${err}`));
-    engine.updateUnspentOutputsForTemplate(templateIdentifier).catch(err => console.error(`Error updating unspent outputs for template ${templateIdentifier}: ${err}`));
+    // engine
+    //   .subscribeToLockingBytecodesForTemplate(templateIdentifier)
+    //   .catch((err) =>
+    //     console.error(
+    //       `Error subscribing to locking bytecodes for template ${templateIdentifier}: ${err}`,
+    //     ),
+    //   );
+    // engine
+    //   .updateUnspentOutputsForTemplate(templateIdentifier)
+    //   .catch((err) =>
+    //     console.error(
+    //       `Error updating unspent outputs for template ${templateIdentifier}: ${err}`,
+    //     ),
+    //   );
+    
+    // Update all the unspents for every template, and subscribe to the locking bytecodes for changes
+    // TODO: Remove the above lines that do the same thing. Minimising changes for BLISS.
+    const updateTemplates = async () => {
+      const templates = await engine.listImportedTemplates();
+
+      templates.forEach(async (template) => {
+        // engine.updateUnspentOutputsForTemplate(generateTemplateIdentifier(template));
+        engine.subscribeToLockingBytecodesForTemplate(generateTemplateIdentifier(template));
+      });
+    };
+
+    updateTemplates();

    // Set default locking parameters for P2PKH
    // To my knowledge, this doesnt generate any lockscript, so discovery of funds will not work automatically.
    // TODO: Add discovery for funds in the first index? Or until we return 0 TXs?
    await engine.setDefaultLockingParameters(
-      generateTemplateIdentifier(p2pkhTemplate),
+      generateTemplateIdentifier(parseTemplate(p2pkhTemplate)),
      "receiveOutput",
      "receiver",
    );
@@ -95,8 +129,9 @@ export class AppService extends EventEmitter<AppEventMap> {
      host: config.electrumHost,
      applicationIdentifier: config.electrumApplicationIdentifier,
    });
+    const rates = await RatesService.create(settings);

-    return new AppService(engine, walletStorage, config, electrum);
+    return new AppService(engine, walletStorage, config, electrum, rates, settings);
  }

  constructor(
@@ -104,6 +139,8 @@ export class AppService extends EventEmitter<AppEventMap> {
    storage: BaseStorage,
    config: AppConfig,
    electrum: BlockchainService,
+    rates: RatesService,
+    settings: SettingsService,
  ) {
    super();

@@ -111,6 +148,8 @@ export class AppService extends EventEmitter<AppEventMap> {
    this.storage = storage;
    this.config = config;
    this.electrum = electrum;
+    this.rates = rates;
+    this.settings = settings;
    this.history = new HistoryService(engine, this.invitations);
  }

@@ -209,10 +248,7 @@ export class AppService extends EventEmitter<AppEventMap> {
    if (!trackedInvitation || !cleanup) return;

    trackedInvitation.off("invitation-updated", cleanup.onUpdated);
-    trackedInvitation.off(
-      "invitation-status-changed",
-      cleanup.onStatusChanged,
-    );
+    trackedInvitation.off("invitation-status-changed", cleanup.onStatusChanged);
    this.invitationEventCleanup.delete(invitationIdentifier);
  }

@@ -248,6 +284,11 @@ export class AppService extends EventEmitter<AppEventMap> {
  }

  async start(): Promise<void> {
+    // Start rates in the background so BCH -> fiat conversions become reactive in the TUI.
+    this.rates.start().catch((err) =>
+      console.error('Error starting rates service:', err),
+    );
+
    // Get the invitations db
    const invitationsDb = this.storage.child("invitations");

@@ -259,7 +300,9 @@ export class AppService extends EventEmitter<AppEventMap> {

    await Promise.all(
      invitations.map(async ({ key }) => {
-        await this.createInvitation(key).catch(err => console.error(`Error creating invitation ${key}: ${err}`));
+        await this.createInvitation(key).catch((err) =>
+          console.error(`Error creating invitation ${key}: ${err}`),
+        );
      }),
    );
  }
--- a/src/services/history.ts
+++ b/src/services/history.ts
--- a/src/services/invitation.ts
+++ b/src/services/invitation.ts
@@ -2,9 +2,9 @@ import type {
  AcceptInvitationParameters,
  AppendInvitationParameters,
  Engine,
-  FindSuitableResourcesParameters,
+  GetSpendableResourcesParameters,
 } from "@xo-cash/engine";
-import { hasInvitationExpired, mergeInvitationCommits } from "@xo-cash/engine";
+import { generateTemplateIdentifier, hasInvitationExpired, mergeInvitationCommits } from "@xo-cash/engine";
 import type {
  XOInvitation,
  XOInvitationCommit,
@@ -34,7 +34,7 @@ import { compileCashAssemblyString } from "@xo-cash/engine";
 export type InvitationEventMap = {
  "invitation-updated": XOInvitation;
  "invitation-status-changed": string;
-  "error": Error;
+  error: Error;
 };

 export type InvitationDependencies = {
@@ -85,8 +85,11 @@ export class Invitation extends EventEmitter<InvitationEventMap> {
      throw new Error(`Template not found: ${invitation.templateIdentifier}`);
    }

+    // engine invitation (I have no idea if this is required)
+    const engineInvitation = await dependencies.engine.acceptInvitation(invitation);
+
    // Create the invitation
-    const invitationInstance = new Invitation(invitation, dependencies);
+    const invitationInstance = new Invitation(engineInvitation, dependencies);

    // Start the invitation and its tracking
    await invitationInstance.start();
@@ -215,7 +218,9 @@ export class Invitation extends EventEmitter<InvitationEventMap> {
  /**
   * Publish the invitation to the sync server
   */
-  private async publishInvitation(invitation: XOInvitation = this.data): Promise<void> {
+  private async publishInvitation(
+    invitation: XOInvitation = this.data,
+  ): Promise<void> {
    try {
      await this.syncServer.publishInvitation(invitation);
    } catch (err) {
@@ -481,13 +486,50 @@ export class Invitation extends EventEmitter<InvitationEventMap> {
  }

  async findSuitableResources(
-    options: Partial<FindSuitableResourcesParameters> = {},
+    options: Partial<GetSpendableResourcesParameters> = {},
  ): Promise<UnspentOutputData[]> {
-    // Find the suitable resources
-    const { unspentOutputs } = await this.engine.findSuitableResources(
-      this.data,
-      options,
-    );
+    const templateIdentifier =
+      options.templateIdentifier ?? this.data.templateIdentifier;
+    const template = await this.engine.getTemplate(templateIdentifier);
+    const fallbackOutputIdentifier = Object.keys(template?.outputs ?? {})[0];
+    if (!fallbackOutputIdentifier && !options.outputIdentifier) {
+      throw new Error(
+        `No output identifiers found for template: ${templateIdentifier}`,
+      );
+    }
+
+    // const resolvedOptions: GetSpendableResourcesParameters = {
+    //   templateIdentifier,
+    //   outputIdentifier: options.outputIdentifier ?? fallbackOutputIdentifier ?? "",
+    // };
+
+    // There are disagreements around whether all spendables should be returned from getSpendableResources.
+    // I had a fix merged in, but it got overwritten. So, im just going to get all of them manually and go around
+    // The engine's expectations.
+    // To do this, we are going to grab all out templates
+    const templates = await this.engine.listImportedTemplates();
+
+    // For each template, we need to create a 2d array of all the outputs
+    const outputs = templates.map(template => {
+      return Object.keys(template.outputs).map(output => {
+        const templateIdentifier = generateTemplateIdentifier(template);
+
+        return {
+          templateIdentifier,
+          outputIdentifier: output,
+        };
+      });
+    });
+
+    // then, for each output, we need to get the spendable resources
+    const spendableResources = await Promise.all(outputs.flat().map(output => {
+      return this.engine.getSpendableResources(this.data, {
+        templateIdentifier: output.templateIdentifier,
+        outputIdentifier: output.outputIdentifier,
+      });
+    }));
+
+    const unspentOutputs = spendableResources.flatMap(resource => resource.unspentOutputs);

    // Update the status of the invitation
    await this.updateStatus();
--- a/src/services/rates.ts
+++ b/src/services/rates.ts
@@ -0,0 +1,217 @@
+import { EventEmitter } from '../utils/event-emitter.js';
+import {
+  type RatesEventMap,
+} from '../utils/rates/base-rates.js';
+import { RatesOracle } from '../utils/rates/rates-oracles.js';
+import { SettingsService } from './settings.js';
+
+/**
+ * Event map emitted by {@link RatesService}.
+ */
+export type RatesServiceEventMap = {
+  'rate-updated': {
+    numeratorUnitCode: string;
+    denominatorUnitCode: string;
+    price: number;
+    pair: string;
+    updatedAt: number;
+  };
+};
+
+/**
+ * In-memory representation of a market rate.
+ */
+type CachedRate = {
+  price: number;
+  updatedAt: number;
+};
+
+/**
+ * Minimal adapter contract that RatesService depends on.
+ *
+ * Using a small interface keeps the service decoupled and avoids inheriting
+ * implementation-specific type constraints from concrete adapters.
+ */
+export interface RatesAdapter {
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  listPairs(): Promise<Set<string>>;
+  formatCurrency(amount: number, targetCurrency: string): string;
+  on(
+    type: 'rateUpdated',
+    listener: (detail: RatesEventMap['rateUpdated']) => void,
+  ): () => void;
+}
+
+/**
+ * Orchestrates the rates adapter lifecycle and provides BCH -> fiat helpers
+ * for the TUI.
+ *
+ * This service keeps a small in-memory snapshot of the latest prices and emits
+ * a normalized event whenever a pair changes. React components can subscribe
+ * through `useSyncExternalStore` for clean and predictable reactivity.
+ */
+export class RatesService extends EventEmitter<RatesServiceEventMap> {
+  private readonly adapter: RatesAdapter;
+  private readonly settings: SettingsService;
+  private readonly ratesByPair = new Map<string, CachedRate>();
+  private unsubscribeFromAdapter: (() => void) | null = null;
+  private started = false;
+
+  constructor(adapter: RatesAdapter, settings: SettingsService) {
+    super();
+    this.adapter = adapter;
+    this.settings = settings;
+  }
+
+  /**
+   * Creates a rates service.
+   *
+   * If no adapter is passed, this defaults to the Oracle-backed adapter.
+   */
+  public static async create(
+    settings: SettingsService,
+    adapter?: RatesAdapter,
+  ): Promise<RatesService> {
+    const resolvedAdapter = adapter ?? (await RatesOracle.from(undefined, settings));
+    return new RatesService(resolvedAdapter, settings);
+  }
+
+  /**
+   * Starts the underlying adapter and begins collecting live updates.
+   */
+  public async start(): Promise<void> {
+    if (this.started) {
+      return;
+    }
+    this.started = true;
+
+    this.unsubscribeFromAdapter = this.adapter.on('rateUpdated', (event) => {
+      this.handleRateUpdated(event);
+    });
+
+    try {
+      await this.adapter.start();
+    } catch (error) {
+      this.unsubscribeFromAdapter?.();
+      this.unsubscribeFromAdapter = null;
+      this.started = false;
+      throw error;
+    }
+  }
+
+  /**
+   * Stops live rate collection.
+   */
+  public async stop(): Promise<void> {
+    if (!this.started) {
+      return;
+    }
+    this.started = false;
+
+    this.unsubscribeFromAdapter?.();
+    this.unsubscribeFromAdapter = null;
+
+    await this.adapter.stop();
+  }
+
+  /**
+   * Returns the latest price for a pair in NUMERATOR/DENOMINATOR form.
+   *
+   * Example: `getRate("USD", "BCH")`.
+   */
+  public getRate(
+    numeratorUnitCode: string,
+    denominatorUnitCode: string,
+  ): number | null {
+    const pair = this.getPairKey(numeratorUnitCode, denominatorUnitCode);
+    return this.ratesByPair.get(pair)?.price ?? null;
+  }
+
+  /**
+   * Converts satoshis to fiat using the latest BCH/fiat rate.
+   *
+   * Example: `convertBchToFiat(1234n, "USD")`.
+   */
+  public convertBchToFiat(
+    satoshis: bigint,
+    targetCurrency: string = 'USD',
+  ): number | null {
+    const rate = this.getRate(targetCurrency, 'BCH');
+    if (rate === null) {
+      return null;
+    }
+
+    const amountInBch = Number(satoshis) / 100_000_000;
+    return amountInBch * rate;
+  }
+
+  /**
+   * Formats a BCH -> fiat converted amount using the adapter formatter.
+   */
+  public formatBchToFiat(
+    satoshis: bigint,
+    targetCurrency: string = 'USD',
+  ): string | null {
+    const normalizedCurrency = targetCurrency.toUpperCase();
+    const amount = this.convertBchToFiat(satoshis, normalizedCurrency);
+    if (amount === null) {
+      return null;
+    }
+    return this.adapter.formatCurrency(amount, normalizedCurrency);
+  }
+
+  /**
+   * Formats an arbitrary fiat amount in a currency-aware way.
+   */
+  public formatCurrency(amount: number, currencyCode: string): string {
+    return this.adapter.formatCurrency(amount, currencyCode.toUpperCase());
+  }
+
+  /**
+   * Lists available market pairs in NUMERATOR/DENOMINATOR format.
+   */
+  public async listPairs(): Promise<Set<string>> {
+    return this.adapter.listPairs();
+  }
+
+  /**
+   * Returns the fiat currency currently configured in settings.
+   */
+  public getConfiguredCurrency(): string {
+    return this.settings.getCurrency();
+  }
+
+  /**
+   * Handles normalized updates from the underlying adapter.
+   */
+  private handleRateUpdated(event: RatesEventMap['rateUpdated']): void {
+    const numeratorUnitCode = event.numeratorUnitCode.toUpperCase();
+    const denominatorUnitCode = event.denominatorUnitCode.toUpperCase();
+    const pair = this.getPairKey(numeratorUnitCode, denominatorUnitCode);
+    const updatedAt = Date.now();
+
+    this.ratesByPair.set(pair, {
+      price: event.price,
+      updatedAt,
+    });
+
+    this.emit('rate-updated', {
+      numeratorUnitCode,
+      denominatorUnitCode,
+      price: event.price,
+      pair,
+      updatedAt,
+    });
+  }
+
+  /**
+   * Creates a stable key for pair lookups.
+   */
+  private getPairKey(
+    numeratorUnitCode: string,
+    denominatorUnitCode: string,
+  ): string {
+    return `${numeratorUnitCode.toUpperCase()}/${denominatorUnitCode.toUpperCase()}`;
+  }
+}
--- a/src/services/settings.ts
+++ b/src/services/settings.ts
@@ -0,0 +1,194 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+
+import { EventEmitter } from "../utils/event-emitter.js";
+import { getSettingsPath } from "../utils/paths.js";
+
+/**
+ * Supported persisted settings keys.
+ */
+export type SettingsData = {
+  "default-mnemonic"?: string;
+  currency: string;
+};
+
+/**
+ * Event payloads emitted by {@link SettingsService}.
+ */
+export type SettingsServiceEventMap = {
+  "settings-updated": {
+    key: keyof SettingsData;
+    value: string | undefined;
+    settings: SettingsData;
+  };
+};
+
+/**
+ * Runtime defaults for settings that should always exist in memory.
+ */
+const DEFAULT_SETTINGS: SettingsData = {
+  currency: "USD",
+};
+
+/**
+ * Handles loading, migrating, and persisting wallet settings.
+ *
+ * The backing file is `~/.config/xo-cli/.wallet`. Historically it stored a raw
+ * mnemonic reference string. This service migrates that legacy format to JSON:
+ * `{ "default-mnemonic": "<value>", "currency": "USD" }`.
+ */
+export class SettingsService extends EventEmitter<SettingsServiceEventMap> {
+  private readonly settingsPath: string;
+  private settings: SettingsData;
+
+  /**
+   * Creates a new settings service instance.
+   *
+   * @param settingsPath - Optional custom settings file path (useful for tests)
+   */
+  constructor(settingsPath: string = getSettingsPath()) {
+    super();
+    this.settingsPath = settingsPath;
+    this.settings = this.loadSettings();
+  }
+
+  /**
+   * Returns the current settings snapshot.
+   */
+  public getSettings(): SettingsData {
+    return { ...this.settings };
+  }
+
+  /**
+   * Returns the currently selected default mnemonic reference.
+   */
+  public getDefaultMnemonic(): string | undefined {
+    return this.settings["default-mnemonic"];
+  }
+
+  /**
+   * Updates the default mnemonic reference and persists it to disk.
+   */
+  public setDefaultMnemonic(mnemonicRef: string): void {
+    const normalizedMnemonicRef = mnemonicRef.trim();
+    if (normalizedMnemonicRef.length === 0) {
+      throw new Error("default-mnemonic cannot be empty");
+    }
+
+    this.settings["default-mnemonic"] = normalizedMnemonicRef;
+    this.persistSettings();
+
+    this.emit("settings-updated", {
+      key: "default-mnemonic",
+      value: normalizedMnemonicRef,
+      settings: this.getSettings(),
+    });
+  }
+
+  /**
+   * Returns the selected fiat currency code (ISO-like uppercase).
+   */
+  public getCurrency(): string {
+    return this.settings.currency;
+  }
+
+  /**
+   * Updates the selected fiat currency and persists it to disk.
+   */
+  public setCurrency(currencyCode: string): void {
+    const normalizedCurrency = this.normalizeCurrency(currencyCode);
+    if (this.settings.currency === normalizedCurrency) {
+      return;
+    }
+
+    this.settings.currency = normalizedCurrency;
+    this.persistSettings();
+
+    this.emit("settings-updated", {
+      key: "currency",
+      value: normalizedCurrency,
+      settings: this.getSettings(),
+    });
+  }
+
+  /**
+   * Reads and normalizes the settings file from disk.
+   *
+   * If the file contains the old legacy format (raw mnemonic string), the
+   * migrated JSON shape is written back immediately.
+   */
+  private loadSettings(): SettingsData {
+    if (!existsSync(this.settingsPath)) {
+      return { ...DEFAULT_SETTINGS };
+    }
+
+    const rawContents = readFileSync(this.settingsPath, "utf8").trim();
+    if (rawContents.length === 0) {
+      return { ...DEFAULT_SETTINGS };
+    }
+
+    try {
+      const parsed = JSON.parse(rawContents);
+      const normalized = this.normalizeSettings(parsed);
+      return normalized;
+    } catch {
+      const migrated = this.normalizeSettings({
+        "default-mnemonic": rawContents,
+      });
+      this.persistSettings(migrated);
+      return migrated;
+    }
+  }
+
+  /**
+   * Writes the given settings object to disk as pretty JSON.
+   *
+   * @param nextSettings - Optional explicit value, defaults to in-memory state
+   */
+  private persistSettings(nextSettings?: SettingsData): void {
+    if (nextSettings) {
+      this.settings = nextSettings;
+    }
+
+    writeFileSync(
+      this.settingsPath,
+      `${JSON.stringify(this.settings, null, 2)}\n`,
+      "utf8",
+    );
+  }
+
+  /**
+   * Coerces unknown input into a safe settings object.
+   */
+  private normalizeSettings(input: unknown): SettingsData {
+    const normalized: SettingsData = {
+      ...DEFAULT_SETTINGS,
+    };
+
+    if (!input || typeof input !== "object") {
+      return normalized;
+    }
+
+    const maybeMnemonic = (input as Record<string, unknown>)["default-mnemonic"];
+    if (typeof maybeMnemonic === "string" && maybeMnemonic.trim().length > 0) {
+      normalized["default-mnemonic"] = maybeMnemonic.trim();
+    }
+
+    const maybeCurrency = (input as Record<string, unknown>).currency;
+    if (typeof maybeCurrency === "string" && maybeCurrency.trim().length > 0) {
+      normalized.currency = this.normalizeCurrency(maybeCurrency);
+    }
+
+    return normalized;
+  }
+
+  /**
+   * Ensures currency values stay uppercase and non-empty.
+   */
+  private normalizeCurrency(currencyCode: string): string {
+    const normalizedCurrency = currencyCode.trim().toUpperCase();
+    if (normalizedCurrency.length === 0) {
+      throw new Error("currency cannot be empty");
+    }
+    return normalizedCurrency;
+  }
+}
--- a/src/services/storage.ts
+++ b/src/services/storage.ts
@@ -1,6 +1,11 @@
 import Database from "better-sqlite3";
 import { decodeExtendedJson, encodeExtendedJson } from "../utils/ext-json.js";

+/**
+ * This is not an actual storage adapter that we want to make use of. This storage adapter is a stop-gap while the engine is under development.
+ * At the time of writing the storage adapter, the engine provided no way to read data about your currenty invitations, so that is where this is coming in.
+ * Its providing a Developer facing way to store/read the invitation data and then we can just import them into the engine whenever we want to interact with an invitation.
+ */
 export abstract class BaseStorage {
  abstract all(): Promise<{ key: string; value: any }[]>;
  abstract set(key: string, value: any): Promise<void>;
@@ -10,6 +15,9 @@ export abstract class BaseStorage {
  abstract child(key: string): BaseStorage;
 }

+/**
+ * SQLite Database Storage Adapter.
+ */
 export class Storage extends BaseStorage {
  static async create(dbPath: string): Promise<Storage> {
    // Create the database
@@ -134,6 +142,9 @@ export class Storage extends BaseStorage {
 *
 * This adapter is useful for tests and short-lived sessions where persisted
 * SQLite state is not needed.
+ * 
+ * TODO: Move this somewhere else. There is no reason for this to be in the main codebase. We should put this stricly in the tests beacuse that were its actually being used.
+ *       Ideally, we would provide these kind of generic fills as part of our packages somewhere, but these interfaces dont fit our current design.
 */
 export class InMemoryStorage extends BaseStorage {
  static async create(): Promise<InMemoryStorage> {
--- a/src/tui/components/CurrencySelectionDialog.tsx
+++ b/src/tui/components/CurrencySelectionDialog.tsx
@@ -0,0 +1,188 @@
+import React, { useEffect, useId, useMemo, useState } from "react";
+import { Box, Text } from "ink";
+
+import { ScrollableList, type ListItemData } from "./List.js";
+import TextInput from "./TextInput.js";
+import { DialogWrapper } from "./Dialog.js";
+import { useInputLayer, useLayeredInput } from "../hooks/useInputLayer.js";
+import { colors } from "../theme.js";
+
+/**
+ * Props for the currency selection dialog.
+ */
+interface CurrencySelectionDialogProps {
+  /** Current wallet currency from persisted settings. */
+  currentCurrency: string;
+  /** Available fiat numerator symbols that can be paired with BCH. */
+  currencies: string[];
+  /** True while the dialog is loading available pairs. */
+  isLoading: boolean;
+  /** Optional loading/error message for pair discovery. */
+  errorMessage: string | null;
+  /** Called when the user chooses a currency and confirms. */
+  onSelectCurrency: (currencyCode: string) => void;
+  /** Called when the dialog should close without applying changes. */
+  onCancel: () => void;
+}
+
+/**
+ * Currency picker dialog.
+ *
+ * UX requirements:
+ * - Arrow keys move the highlighted item.
+ * - Typing immediately filters results.
+ * - Enter applies current selection.
+ * - Escape closes without saving.
+ */
+export function CurrencySelectionDialog({
+  currentCurrency,
+  currencies,
+  isLoading,
+  errorMessage,
+  onSelectCurrency,
+  onCancel,
+}: CurrencySelectionDialogProps): React.ReactElement {
+  const layerId = useId();
+  const [filterText, setFilterText] = useState("");
+  const [selectedIndex, setSelectedIndex] = useState(0);
+
+  // Mount this as a capturing input layer so background screens stop handling keys.
+  useInputLayer(layerId);
+
+  /**
+   * Applies the currently selected filtered result.
+   */
+  const applySelection = (): void => {
+    const selectedCurrency = filteredCurrencies[selectedIndex];
+    if (!selectedCurrency) {
+      return;
+    }
+    onSelectCurrency(selectedCurrency);
+  };
+
+  useLayeredInput(layerId, (_input, key) => {
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+
+    if (key.upArrow) {
+      setSelectedIndex((prev) =>
+        prev <= 0 ? Math.max(filteredCurrencies.length - 1, 0) : prev - 1,
+      );
+      return;
+    }
+
+    if (key.downArrow) {
+      setSelectedIndex((prev) =>
+        filteredCurrencies.length === 0
+          ? 0
+          : prev >= filteredCurrencies.length - 1
+            ? 0
+            : prev + 1,
+      );
+      return;
+    }
+
+  });
+
+  /**
+   * Filter currencies as the user types.
+   */
+  const filteredCurrencies = useMemo(() => {
+    const normalizedFilter = filterText.trim().toUpperCase();
+    if (!normalizedFilter) {
+      return currencies;
+    }
+    return currencies.filter((currencyCode) =>
+      currencyCode.toUpperCase().includes(normalizedFilter),
+    );
+  }, [currencies, filterText]);
+
+  /**
+   * Keep selected index valid whenever filtering shrinks the result set.
+   */
+  useEffect(() => {
+    if (filteredCurrencies.length === 0) {
+      setSelectedIndex(0);
+      return;
+    }
+
+    if (selectedIndex >= filteredCurrencies.length) {
+      setSelectedIndex(filteredCurrencies.length - 1);
+    }
+  }, [filteredCurrencies, selectedIndex]);
+
+  /**
+   * When the dialog opens or the list updates, default to current currency.
+   */
+  useEffect(() => {
+    if (filterText.trim().length > 0) {
+      return;
+    }
+
+    const currentIndex = filteredCurrencies.findIndex(
+      (currencyCode) => currencyCode.toUpperCase() === currentCurrency.toUpperCase(),
+    );
+    if (currentIndex >= 0) {
+      setSelectedIndex(currentIndex);
+    }
+  }, [filteredCurrencies, currentCurrency, filterText]);
+
+  const listItems: ListItemData<string>[] = filteredCurrencies.map(
+    (currencyCode) => ({
+      key: currencyCode,
+      label: currencyCode,
+      description:
+        currencyCode.toUpperCase() === currentCurrency.toUpperCase()
+          ? "(current)"
+          : undefined,
+      value: currencyCode,
+    }),
+  );
+
+  return (
+    <DialogWrapper title="Select Fiat Currency" borderColor={colors.info} width={64}>
+      <Text color={colors.textMuted}>
+        Available BCH quote pairs are loaded from the live rates adapter.
+      </Text>
+
+      <Box marginTop={1}>
+        <Text color={colors.primary}>Filter:</Text>
+      </Box>
+      <Box borderStyle="single" borderColor={colors.focus} paddingX={1}>
+        <TextInput
+          value={filterText}
+          onChange={setFilterText}
+          onSubmit={() => applySelection()}
+          placeholder="Type currency code (e.g. USD, AUD)..."
+          focus
+        />
+      </Box>
+
+      <Box marginTop={1} flexDirection="column">
+        {isLoading ? (
+          <Text color={colors.textMuted}>Loading available pairs...</Text>
+        ) : errorMessage ? (
+          <Text color={colors.error}>{errorMessage}</Text>
+        ) : (
+          <ScrollableList
+            items={listItems}
+            selectedIndex={selectedIndex}
+            onSelect={setSelectedIndex}
+            onActivate={() => applySelection()}
+            focus={false}
+            maxVisible={8}
+            emptyMessage="No BCH quote pairs match this filter."
+          />
+        )}
+      </Box>
+
+      <Box marginTop={1}>
+        <Text color={colors.textMuted}>
+          Type to filter • ↑↓ navigate • Enter apply • Esc cancel
+        </Text>
+      </Box>
+    </DialogWrapper>
+  );
+}
--- a/src/tui/components/QRCode.tsx
+++ b/src/tui/components/QRCode.tsx
@@ -47,6 +47,8 @@ interface QRCodeProps {
  dialogTitle?: string;
  /** Whether to display the raw encoded value as copyable text above the QR code. */
  showValue?: boolean;
+  /** Optional subtitle to display below the QR code. */
+  subtitle?: React.ReactNode;
 }

 /**
@@ -155,6 +157,7 @@ export function QRCode({
  dialog = false,
  dialogTitle = 'QR Code',
  showValue = false,
+  subtitle = null,
 }: QRCodeProps): React.ReactElement {
  const { rows, moduleCount } = useMemo(() => {
    const matrix = generateMatrix(value);
@@ -190,6 +193,7 @@ export function QRCode({
    return (
      <DialogWrapper title={dialogTitle} borderColor={colors.primary} width={dialogWidth}>
        {qrContent}
+        {subtitle}
      </DialogWrapper>
    );
  }
--- a/src/tui/components/VariableInputField.tsx
+++ b/src/tui/components/VariableInputField.tsx
@@ -1,6 +1,7 @@
-import React from "react";
+import React, { useMemo } from "react";
 import { Box, Text } from "ink";
 import TextInput from "./TextInput.js";
+import { useSatoshisConversion } from "../hooks/useSatoshisConversion.js";

 interface VariableInputFieldProps {
  variable: {
@@ -18,6 +19,45 @@ interface VariableInputFieldProps {
  focusColor: string;
 }

+const SATOSHIS_PER_BCH = 100_000_000n;
+
+/**
+ * Returns true when the variable is an integer satoshis field.
+ */
+function isSatoshisVariable(variable: VariableInputFieldProps["variable"]): boolean {
+  return (
+    variable.type === "integer" &&
+    variable.hint?.toLowerCase().includes("satoshi") === true
+  );
+}
+
+/**
+ * Parse a strict integer string into bigint.
+ */
+function parseSatoshis(value: string): bigint | null {
+  const trimmed = value.trim();
+  if (!/^[-]?\d+$/.test(trimmed)) {
+    return null;
+  }
+
+  try {
+    return BigInt(trimmed);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Format satoshis as BCH with fixed 8 decimals, preserving bigint precision.
+ */
+function formatBchFromSatoshis(satoshis: bigint): string {
+  const sign = satoshis < 0n ? "-" : "";
+  const absolute = satoshis < 0n ? satoshis * -1n : satoshis;
+  const whole = absolute / SATOSHIS_PER_BCH;
+  const fractional = absolute % SATOSHIS_PER_BCH;
+  return `${sign}${whole.toString()}.${fractional.toString().padStart(8, "0")} BCH`;
+}
+
 export function VariableInputField({
  variable,
  index,
@@ -27,6 +67,26 @@ export function VariableInputField({
  borderColor,
  focusColor,
 }: VariableInputFieldProps): React.ReactElement {
+  const { currencyCode, formattedFiatPerBchRate, formatSatoshisToFiat } =
+    useSatoshisConversion();
+  const satoshisValue = useMemo(
+    () => parseSatoshis(variable.value),
+    [variable.value],
+  );
+  const formattedBch = useMemo(() => {
+    if (satoshisValue === null) {
+      return null;
+    }
+    return formatBchFromSatoshis(satoshisValue);
+  }, [satoshisValue]);
+  const formattedFiat = useMemo(() => {
+    if (satoshisValue === null) {
+      return null;
+    }
+    return formatSatoshisToFiat(satoshisValue);
+  }, [satoshisValue, formatSatoshisToFiat]);
+  const shouldShowSatoshisConversion = isSatoshisVariable(variable);
+
  return (
    <Box flexDirection="column" marginBottom={1}>
      <Text color={focusColor}>{variable.name}</Text>
@@ -54,12 +114,29 @@ export function VariableInputField({
        <Text color={borderColor} dimColor>{variable.hint}</Text>
        
      </Box>
-      {variable.type === 'integer' && variable.hint === 'satoshis' && (
-        <Box>
-          <Text color={borderColor} dimColor>
-            {/* Convert from sats to bch. NOTE: we can't use the formatSatoshis function because it is too verbose and returns too many values in the string*/}
-            {(Number(variable.value) / 100_000_000).toFixed(8)} BCH
-          </Text>
+      {shouldShowSatoshisConversion && (
+        <Box flexDirection="column">
+          {formattedBch ? (
+            <>
+              <Text color={borderColor} dimColor>
+                {formattedBch}
+              </Text>
+              <Text color={borderColor} dimColor>
+                {formattedFiat
+                  ? `Approx. ${currencyCode}: ${formattedFiat}`
+                  : `Approx. ${currencyCode}: waiting for live rate...`}
+              </Text>
+              {formattedFiatPerBchRate && (
+                <Text color={borderColor} dimColor>
+                  1 BCH = {formattedFiatPerBchRate}
+                </Text>
+              )}
+            </>
+          ) : (
+            <Text color={borderColor} dimColor>
+              Enter a whole satoshi amount to preview BCH/{currencyCode} conversion.
+            </Text>
+          )}
        </Box>
      )}
    </Box>
--- a/src/tui/hooks/index.ts
+++ b/src/tui/hooks/index.ts
@@ -23,3 +23,5 @@ export {
  useBlockableInput,
  useIsInputCaptured,
 } from "./useInputLayer.js";
+export { useRate, useBchToFiatRate } from "./useRates.js";
+export { useSatoshisConversion } from "./useSatoshisConversion.js";
--- a/src/tui/hooks/useRates.tsx
+++ b/src/tui/hooks/useRates.tsx
@@ -0,0 +1,68 @@
+import { useCallback, useMemo, useSyncExternalStore } from 'react';
+import type { RatesServiceEventMap } from '../../services/rates.js';
+import { useAppContext } from './useAppContext.js';
+
+/**
+ * Reactive hook for a single market pair.
+ *
+ * Pair format is NUMERATOR / DENOMINATOR, e.g. USD / BCH.
+ */
+export function useRate(
+  numeratorUnitCode: string,
+  denominatorUnitCode: string,
+): number | null {
+  const { appService } = useAppContext();
+
+  const normalizedNumerator = useMemo(
+    () => numeratorUnitCode.toUpperCase(),
+    [numeratorUnitCode],
+  );
+  
+  const normalizedDenominator = useMemo(
+    () => denominatorUnitCode.toUpperCase(),
+    [denominatorUnitCode],
+  );
+
+  const subscribe = useCallback(
+    (callback: () => void) => {
+      if (!appService) {
+        return () => {};
+      }
+
+      const onRateUpdated = (event: RatesServiceEventMap['rate-updated']) => {
+        if (
+          event.numeratorUnitCode === normalizedNumerator &&
+          event.denominatorUnitCode === normalizedDenominator
+        ) {
+          callback();
+        }
+      };
+
+      const unsubscribe = appService.rates.on('rate-updated', onRateUpdated);
+
+      return () => {
+        unsubscribe();
+      };
+    },
+    [appService, normalizedNumerator, normalizedDenominator],
+  );
+
+  const getSnapshot = useCallback(() => {
+    if (!appService) {
+      return null;
+    }
+
+    return appService.rates.getRate(normalizedNumerator, normalizedDenominator);
+  }, [appService, normalizedNumerator, normalizedDenominator]);
+
+  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+}
+
+/**
+ * Convenience hook for BCH -> fiat market rates.
+ */
+export function useBchToFiatRate(
+  targetCurrency: string = 'USD',
+): number | null {
+  return useRate(targetCurrency, 'BCH');
+}
--- a/src/tui/hooks/useSatoshisConversion.tsx
+++ b/src/tui/hooks/useSatoshisConversion.tsx
@@ -0,0 +1,73 @@
+import { useCallback, useMemo, useSyncExternalStore } from 'react';
+import { useAppContext } from './useAppContext.js';
+import { useBchToFiatRate } from './useRates.js';
+
+/**
+ * Reactive BCH satoshis -> fiat conversion helpers for TUI screens.
+ *
+ * This hook subscribes to rate updates through `useBchToFiatRate`, so any
+ * component using it will re-render automatically when the selected pair
+ * receives a new quote.
+ */
+export function useSatoshisConversion(targetCurrency?: string) {
+  const { appService } = useAppContext();
+  const subscribeToCurrency = useCallback(
+    (callback: () => void) => {
+      if (!appService || targetCurrency) {
+        return () => {};
+      }
+
+      return appService.settings.on('settings-updated', (event) => {
+        if (event.key === 'currency') {
+          callback();
+        }
+      });
+    },
+    [appService, targetCurrency],
+  );
+
+  const getCurrencySnapshot = useCallback(() => {
+    if (targetCurrency) {
+      return targetCurrency.toUpperCase();
+    }
+
+    if (!appService) {
+      return 'USD';
+    }
+
+    return appService.settings.getCurrency();
+  }, [appService, targetCurrency]);
+
+  const currencyCode = useSyncExternalStore(
+    subscribeToCurrency,
+    getCurrencySnapshot,
+    getCurrencySnapshot,
+  );
+  const fiatPerBchRate = useBchToFiatRate(currencyCode);
+
+  const formattedFiatPerBchRate = useMemo(() => {
+    if (!appService || fiatPerBchRate === null) {
+      return null;
+    }
+
+    return appService.rates.formatCurrency(fiatPerBchRate, currencyCode);
+  }, [appService, fiatPerBchRate, currencyCode]);
+
+  const formatSatoshisToFiat = useCallback(
+    (satoshis: bigint): string | null => {
+      if (!appService || fiatPerBchRate === null) {
+        return null;
+      }
+
+      return appService.rates.formatBchToFiat(satoshis, currencyCode);
+    },
+    [appService, fiatPerBchRate, currencyCode],
+  );
+
+  return {
+    currencyCode,
+    fiatPerBchRate,
+    formattedFiatPerBchRate,
+    formatSatoshisToFiat,
+  } as const;
+}
--- a/src/tui/screens/SeedInput.tsx
+++ b/src/tui/screens/SeedInput.tsx
@@ -19,7 +19,7 @@ import path from 'path';
 import { createMnemonicFile } from '../../cli/mnemonic.js';
 import { getMnemonicsDir } from '../../utils/paths.js';
 import { BCHMnemonicURL } from '../../utils/bch-mnemonic-url.js';
-import { encodeBip39Mnemonic } from '@bitauth/libauth';
+import { encodeBip39Mnemonic, generateBip39Mnemonic } from '@bitauth/libauth';

 /**
 * Status message type.
@@ -41,7 +41,7 @@ interface MnemonicFileEntry {
 * Focus sections the user can tab between.
 * When saved wallets exist the file list is shown first.
 */
-type FocusSection = 'files' | 'input' | 'saveCheckbox' | 'button';
+type FocusSection = 'files' | 'input' | 'saveCheckbox' | 'generateRandomSeed' | 'button';

 /**
 * Reads mnemonic-* files from ~/.config/xo-cli/mnemonics/ (same as xo-cli),
@@ -117,8 +117,8 @@ export function SeedInputScreen(): React.ReactElement {
   * The ordered list of focusable sections (files section only when entries exist).
   */
  const focusSections: FocusSection[] = mnemonicFiles.length > 0
-    ? ['files', 'input', 'saveCheckbox', 'button']
-    : ['input', 'saveCheckbox', 'button'];
+    ? ['files', 'input', 'generateRandomSeed', 'saveCheckbox', 'button']
+    : ['input', 'generateRandomSeed', 'saveCheckbox', 'button'];

  /**
   * Shows a status message with the given type.
@@ -202,7 +202,7 @@ export function SeedInputScreen(): React.ReactElement {
  }, [mnemonicFiles, doInitialize]);

  // Keyboard navigation
-  useBlockableInput((_input, key) => {
+  useBlockableInput((input, key) => {
    if (isSubmitting) return;

    // Tab / Shift-Tab to cycle focus sections
@@ -219,7 +219,7 @@ export function SeedInputScreen(): React.ReactElement {

    // Space or Enter toggles "save mnemonic" when that row is focused
    if (focusedSection === 'saveCheckbox') {
-      if (_input === ' ' || key.return) {
+      if (input === ' ' || key.return) {
        setSaveMnemonicChecked((v) => !v);
        return;
      }
@@ -241,6 +241,18 @@ export function SeedInputScreen(): React.ReactElement {
      }
    }

+    // Ctrl-R generates a random seed phrase and fills it in the input
+    if (key.ctrl && input === 'r') {
+      setSeedPhrase(generateBip39Mnemonic());
+      return;
+    }
+
+    // If pressing enter while the generate random seed section is focused, generate a random seed and fill it in the input
+    if (key.return && focusedSection === 'generateRandomSeed') {
+      setSeedPhrase(generateBip39Mnemonic());
+      return;
+    }
+
    // Enter on button submits manual seed
    if (key.return && focusedSection === 'button') {
      handleSubmit();
@@ -358,6 +370,19 @@ export function SeedInputScreen(): React.ReactElement {
          />
        </Box>

+        {/* Generate random seed phrase and fill in the input */}
+        <Box marginTop={1}>
+          <Box
+            paddingX={1}
+            paddingY={0}
+            backgroundColor={focusedSection === 'generateRandomSeed' ? colors.focus : colors.bgSelected}
+          >
+            <Text color={focusedSection === 'generateRandomSeed' ? colors.bg : colors.text} bold>Generate Random Seed</Text>
+          </Box>
+
+          <Text color={colors.textMuted}> (Ctrl-R)</Text>
+        </Box>
+
        {/* Save mnemonic checkbox (manual entry only; applies on Continue) */}
        <Box
          marginTop={1}
--- a/src/tui/screens/TemplateList.tsx
+++ b/src/tui/screens/TemplateList.tsx
@@ -100,8 +100,8 @@ export function TemplateListScreen(): React.ReactElement {
          for (const startingAction of rawStartingActions) {
            const existing = actionMap.get(startingAction.action);
            if (existing) {
-              if (!existing.roles.includes(startingAction.role)) {
-                existing.roles.push(startingAction.role);
+              if (!existing.roles.includes(startingAction.role ?? '')) {
+                existing.roles.push(startingAction.role ?? '');
              }
              continue;
            }
@@ -111,7 +111,7 @@ export function TemplateListScreen(): React.ReactElement {
              actionIdentifier: startingAction.action,
              name: actionDef?.name || startingAction.action,
              description: actionDef?.description,
-              roles: [startingAction.role],
+              roles: [startingAction.role ?? ''],
              source: 'starting',
            });
          }
@@ -119,9 +119,9 @@ export function TemplateListScreen(): React.ReactElement {
          const ownedOutputIdentifiers = ownedOutputsByTemplate.get(templateIdentifier) ?? new Set<string>();
          for (const outputIdentifier of ownedOutputIdentifiers) {
            const outputDef = template.outputs?.[outputIdentifier];
-            if (!outputDef || typeof outputDef.lockscript !== 'string') continue;
+            if (!outputDef || typeof outputDef.lockingScript !== 'string') continue;

-            const lockingScriptDefinition = (template.lockingScripts as Record<string, unknown> | undefined)?.[outputDef.lockscript] as
+            const lockingScriptDefinition = (template.lockingScripts as Record<string, unknown> | undefined)?.[outputDef.lockingScript] as
              | { roles?: Record<string, { actions?: Array<{ action?: string; role?: string } | string> }> }
              | undefined;
            if (!lockingScriptDefinition?.roles) continue;
@@ -217,14 +217,10 @@ export function TemplateListScreen(): React.ReactElement {
        action.roles.length,
        index
      );
-      const sourceSuffix = action.source === 'next'
-        ? ' [next]'
-        : action.source === 'starting+next'
-          ? ' [start+next]'
-          : '';
+
      return {
        key: action.actionIdentifier,
-        label: `${formatted.label}${sourceSuffix}`,
+        label: `${formatted.label}`,
        description: formatted.description,
        value: action,
        hidden: !formatted.isValid,
--- a/src/tui/screens/WalletState.tsx
+++ b/src/tui/screens/WalletState.tsx
@@ -11,8 +11,10 @@ import React, { useState, useEffect, useCallback, useMemo } from 'react';
 import { Box, Text } from 'ink';
 import { ScrollableList, type ListItemData } from '../components/List.js';
 import { QRCode } from '../components/QRCode.js';
+import { CurrencySelectionDialog } from '../components/CurrencySelectionDialog.js';
 import { useNavigation } from '../hooks/useNavigation.js';
 import { useAppContext, useStatus } from '../hooks/useAppContext.js';
+import { useSatoshisConversion } from '../hooks/useSatoshisConversion.js';
 import { useInputLayer, useLayeredInput, useBlockableInput, useIsInputCaptured } from '../hooks/useInputLayer.js';
 import { colors, formatSatoshis, formatHex, logoSmall } from '../theme.js';
 import type { HistoryItem } from '../../services/history.js';
@@ -28,6 +30,7 @@ import {
  type HistoryDisplayRow,
  type HistoryColorName,
 } from '../../utils/history-utils.js';
+import { copyToClipboard } from '../utils/clipboard.js';

 /**
 * Map history color name to theme color.
@@ -58,6 +61,7 @@ const menuItems: ListItemData<string>[] = [
  { key: 'import', label: 'Import Invitation', value: 'import' },
  { key: 'invitations', label: 'View Invitations', value: 'invitations' },
  { key: 'new-address', label: 'Generate New Address', value: 'new-address' },
+  { key: 'set-currency', label: 'Set Fiat Currency', value: 'set-currency' },
  { key: 'unreserve-all', label: 'Unreserve All Resources', value: 'unreserve-all' },
  { key: 'refresh', label: 'Refresh', value: 'refresh' },
 ];
@@ -74,7 +78,10 @@ type HistoryListItem = ListItemData<HistoryDisplayRow>;
 function QRDialogOverlay({ address, onClose }: { address: string; onClose: () => void }): React.ReactElement {
  useInputLayer('qr-dialog');

-  useLayeredInput('qr-dialog', (_input, key) => {
+  useLayeredInput('qr-dialog', (input, key) => {
+    if (input === 'c' || input === 'C') {
+      copyToClipboard(address);
+    }
    if (key.escape || key.return) {
      onClose();
    }
@@ -92,10 +99,13 @@ function QRDialogOverlay({ address, onClose }: { address: string; onClose: () =>
        dialog
        dialogTitle="Receive Address"
        showValue
+        subtitle={
+          <Box flexDirection="column" justifyContent="center" marginTop={1}>
+            <Text color={colors.textMuted}>Press C to copy to clipboard</Text>
+            <Text color={colors.textMuted}>Press Enter or Esc to close</Text>
+          </Box>
+        }
      />
-      <Box justifyContent="center" marginTop={1}>
-        <Text color={colors.textMuted}>Press Enter or Esc to close</Text>
-      </Box>
    </Box>
  );
 }
@@ -108,6 +118,12 @@ export function WalletStateScreen(): React.ReactElement {
  const { navigate } = useNavigation();
  const { appService, showError, showInfo } = useAppContext();
  const { setStatus } = useStatus();
+  const {
+    currencyCode,
+    fiatPerBchRate,
+    formattedFiatPerBchRate,
+    formatSatoshisToFiat,
+  } = useSatoshisConversion();

  // State
  const [balance, setBalance] = useState<{ totalSatoshis: bigint; utxoCount: number } | null>(null);
@@ -119,6 +135,14 @@ export function WalletStateScreen(): React.ReactElement {

  /** Cash address to display in the QR code dialog (null when dialog is hidden). */
  const [qrAddress, setQrAddress] = useState<string | null>(null);
+  /** Whether the fiat currency selection dialog is open. */
+  const [isCurrencyDialogOpen, setCurrencyDialogOpen] = useState(false);
+  /** Loading state for rates pair discovery. */
+  const [isLoadingCurrencyPairs, setLoadingCurrencyPairs] = useState(false);
+  /** Optional error message shown in the currency dialog. */
+  const [currencyPairsError, setCurrencyPairsError] = useState<string | null>(null);
+  /** Available fiat currencies derived from rates pairs in X/BCH format. */
+  const [availableCurrencies, setAvailableCurrencies] = useState<string[]>([]);

  /**
   * Refreshes wallet state.
@@ -246,6 +270,89 @@ export function WalletStateScreen(): React.ReactElement {
    }
  }, [appService, setStatus, showError, showInfo, refresh]);

+  /**
+   * Loads all available rates pairs, then extracts fiat numerator symbols from
+   * pairs shaped like X/BCH.
+   *
+   * We retry briefly because rates startup is asynchronous and metadata can take
+   * a moment to hydrate right after wallet initialization.
+   */
+  const loadAvailableCurrencies = useCallback(async (): Promise<void> => {
+    if (!appService) {
+      setCurrencyPairsError("AppService not initialized");
+      return;
+    }
+
+    setLoadingCurrencyPairs(true);
+    setCurrencyPairsError(null);
+
+    try {
+      let pairs = new Set<string>();
+
+      // Retry a few times so we can catch late metadata initialization.
+      for (let attempt = 0; attempt < 4; attempt += 1) {
+        pairs = await appService.rates.listPairs();
+        if (pairs.size > 0) {
+          break;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 200));
+      }
+
+      const currencies = Array.from(pairs)
+        .map((pair) => pair.toUpperCase())
+        .filter((pair) => pair.endsWith("/BCH"))
+        .map((pair) => pair.split("/")[0] ?? "")
+        .filter((currency) => currency.length > 0)
+        .sort((a, b) => a.localeCompare(b));
+
+      const uniqueCurrencies = Array.from(new Set(currencies));
+      setAvailableCurrencies(uniqueCurrencies);
+
+      if (uniqueCurrencies.length === 0) {
+        setCurrencyPairsError(
+          "No X/BCH rates are currently available. Try again in a moment.",
+        );
+      }
+    } catch (error) {
+      setCurrencyPairsError(
+        `Failed to load currency pairs: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    } finally {
+      setLoadingCurrencyPairs(false);
+    }
+  }, [appService]);
+
+  /**
+   * Opens the fiat currency dialog and triggers pair discovery.
+   */
+  const openCurrencyDialog = useCallback(() => {
+    setCurrencyDialogOpen(true);
+    void loadAvailableCurrencies();
+  }, [loadAvailableCurrencies]);
+
+  /**
+   * Applies the selected fiat currency to persisted settings.
+   */
+  const applyCurrencySelection = useCallback(
+    (currencyCode: string) => {
+      if (!appService) {
+        showError("AppService not initialized");
+        return;
+      }
+
+      try {
+        appService.settings.setCurrency(currencyCode);
+        setStatus(`Fiat currency updated to ${currencyCode}`);
+        setCurrencyDialogOpen(false);
+      } catch (error) {
+        showError(
+          `Failed to update currency: ${error instanceof Error ? error.message : String(error)}`,
+        );
+      }
+    },
+    [appService, setStatus, showError],
+  );
+
  /**
   * Handles menu action.
   */
@@ -263,6 +370,9 @@ export function WalletStateScreen(): React.ReactElement {
      case 'new-address':
        generateNewAddress();
        break;
+      case 'set-currency':
+        openCurrencyDialog();
+        break;
      case 'unreserve-all':
        unreserveAll();
        break;
@@ -270,7 +380,7 @@ export function WalletStateScreen(): React.ReactElement {
        refresh();
        break;
    }
-  }, [navigate, generateNewAddress, unreserveAll, refresh]);
+  }, [navigate, generateNewAddress, openCurrencyDialog, unreserveAll, refresh]);

  /**
   * Handle menu item activation.
@@ -297,6 +407,26 @@ export function WalletStateScreen(): React.ReactElement {
    });
  }, [history]);

+  /**
+   * Fiat values are memoized so we only recompute when balance or rate changes.
+   */
+  const formattedUsdPerBchRate = useMemo(() => {
+    return formattedFiatPerBchRate;
+  }, [formattedFiatPerBchRate]);
+
+  const formattedUsdBalance = useMemo(() => {
+    if (!balance || fiatPerBchRate === null) {
+      return null;
+    }
+
+    return formatSatoshisToFiat(balance.totalSatoshis);
+  }, [balance, fiatPerBchRate, formatSatoshisToFiat]);
+
+  const getFiatSuffix = useCallback((satoshis: bigint): string => {
+    const fiatValue = formatSatoshisToFiat(satoshis);
+    return fiatValue ? ` (~${fiatValue})` : '';
+  }, [formatSatoshisToFiat]);
+
  // Screen input — automatically blocked when any dialog/overlay is capturing.
  const isCaptured = useIsInputCaptured();

@@ -323,24 +453,32 @@ export function WalletStateScreen(): React.ReactElement {
    const indicator = isFocused ? '▸ ' : '  ';
    const groupingPrefix = row.isNested ? '  -> ' : '';

-    if (row.type === 'invitation') {
+    if (row.type === 'history_item') {
+      const sats = row.valueSatoshis ?? 0n;
+      const fiatSuffix = getFiatSuffix(sats);
      return (
        <Box flexDirection="row" justifyContent="space-between">
-          <Text color={itemColor}>
-            {indicator}[Invitation] {row.label}
-          </Text>
+          <Box flexDirection="row">
+            <Text color={itemColor}>
+              {indicator}{formatSatoshis(sats)}{fiatSuffix}
+            </Text>
+            <Text color={colors.textMuted}> {row.label}</Text>
+          </Box>
          {dateStr && <Text color={colors.textMuted}>{dateStr}</Text>}
        </Box>
      );
    }

-    if (row.type === 'invitation_input') {
+    if (row.type === 'history_input') {
+      const sats = row.valueSatoshis ?? 0n;
      return (
        <Box flexDirection="row" justifyContent="space-between">
          <Box>
            <Text color={itemColor}>
-              {indicator}{groupingPrefix}[Input] {row.label}
+              {indicator}{groupingPrefix}[Input] {formatSatoshis(sats)}
+              {getFiatSuffix(sats)}
            </Text>
+            <Text color={colors.textMuted}> {row.label}</Text>
            {row.description && <Text color={colors.textMuted}> {row.description}</Text>}
          </Box>
          {dateStr && <Text color={colors.textMuted}>{dateStr}</Text>}
@@ -348,14 +486,17 @@ export function WalletStateScreen(): React.ReactElement {
      );
    }

-    if (row.type === 'invitation_output') {
-      const sats = row.utxo?.valueSatoshis ?? 0n;
+    if (row.type === 'history_output') {
+      const sats = row.valueSatoshis ?? 0n;
+      const reservedTag = row.reserved ? ' [Reserved]' : '';
      return (
        <Box flexDirection="row" justifyContent="space-between">
          <Box flexDirection="row">
            <Text color={itemColor}>
              {indicator}{groupingPrefix}[Output] {formatSatoshis(sats)}
+              {getFiatSuffix(sats)}
            </Text>
+            <Text color={colors.textMuted}> {row.label}{reservedTag}</Text>
            {row.description && <Text color={colors.textMuted}> {row.description}</Text>}
          </Box>
          {dateStr && <Text color={colors.textMuted}>{dateStr}</Text>}
@@ -363,20 +504,6 @@ export function WalletStateScreen(): React.ReactElement {
      );
    }

-    if (row.type === 'utxo') {
-      const sats = row.utxo?.valueSatoshis ?? 0n;
-      const reservedTag = row.utxo?.reserved ? ' [Reserved]' : '';
-      return (
-        <Box flexDirection="row" justifyContent="space-between">
-          <Box flexDirection="row">
-            <Text color={itemColor}>{indicator}{formatSatoshis(sats)}</Text>
-            {row.description && <Text color={colors.textMuted}> {row.description}{reservedTag}</Text>}
-          </Box>
-          {dateStr && <Text color={colors.textMuted}>{dateStr}</Text>}
-        </Box>
-      );
-    }
-
    // Fallback for other types
    return (
      <Box flexDirection="row" justifyContent="space-between">
@@ -386,7 +513,7 @@ export function WalletStateScreen(): React.ReactElement {
        {dateStr && <Text color={colors.textMuted}>{dateStr}</Text>}
      </Box>
    );
-  }, []);
+  }, [getFiatSuffix]);

  return (
    <Box flexDirection="column" flexGrow={1}>
@@ -418,6 +545,20 @@ export function WalletStateScreen(): React.ReactElement {
                  <Text color={colors.success} bold>
                    {formatSatoshis(balance.totalSatoshis)}
                  </Text>
+                  {formattedUsdBalance ? (
+                    <Text color={colors.info}>
+                      Approx. Fiat ({currencyCode}): {formattedUsdBalance}
+                    </Text>
+                  ) : (
+                    <Text color={colors.textMuted}>
+                      Approx. Fiat ({currencyCode}): Waiting for BCH/{currencyCode} rate...
+                    </Text>
+                  )}
+                  {formattedUsdPerBchRate && (
+                    <Text color={colors.textMuted}>
+                      1 BCH = {formattedUsdPerBchRate}
+                    </Text>
+                  )}
                  <Text color={colors.textMuted}>
                    UTXOs: {balance.utxoCount}
                  </Text>
@@ -465,7 +606,7 @@ export function WalletStateScreen(): React.ReactElement {
          height={14}
          overflow="hidden"
        >
-          <Text color={colors.primary} bold> Wallet History {history.length > 0 ? `(${selectedHistoryIndex + 1}/${history.length})` : ''}</Text>
+          <Text color={colors.primary} bold> Wallet History {historyListItems.length > 0 ? `(${selectedHistoryIndex + 1}/${historyListItems.length})` : ''}</Text>
          {isLoading ? (
            <Box marginTop={1}>
              <Text color={colors.textMuted}>Loading...</Text>
@@ -498,6 +639,27 @@ export function WalletStateScreen(): React.ReactElement {
          onClose={() => setQrAddress(null)}
        />
      )}
+
+      {/* Fiat currency selection dialog overlay */}
+      {isCurrencyDialogOpen && (
+        <Box
+          position="absolute"
+          flexDirection="column"
+          alignItems="center"
+          justifyContent="center"
+          width="100%"
+          height="100%"
+        >
+          <CurrencySelectionDialog
+            currentCurrency={currencyCode}
+            currencies={availableCurrencies}
+            isLoading={isLoadingCurrencyPairs}
+            errorMessage={currencyPairsError}
+            onSelectCurrency={applyCurrencySelection}
+            onCancel={() => setCurrencyDialogOpen(false)}
+          />
+        </Box>
+      )}
    </Box>
  );
 }
--- a/src/tui/screens/action-wizard/flows/index.ts
+++ b/src/tui/screens/action-wizard/flows/index.ts
@@ -15,7 +15,7 @@ export { DataWizardFlow } from "./DataWizardFlow.js";
 */
 export function createWizardFlow(action: XOTemplateAction): WizardFlow {
  if (action.data?.length && !action.transaction) {
-    return new DataWizardFlow(action.data);
+    return new DataWizardFlow([action.data]);
  }
  return new TransactionWizardFlow();
 }
--- a/src/tui/screens/action-wizard/steps/InputsStep.tsx
+++ b/src/tui/screens/action-wizard/steps/InputsStep.tsx
@@ -1,6 +1,7 @@
 import React from 'react';
 import { Box, Text } from 'ink';
 import { colors, formatSatoshis, formatHex } from '../../../theme.js';
+import { useSatoshisConversion } from '../../../hooks/useSatoshisConversion.js';
 import type { SelectableUTXO, FocusArea } from '../types.js';

 interface Props {
@@ -22,6 +23,13 @@ export function InputsStep({
  changeAmount,
  focusArea,
 }: Props): React.ReactElement {
+  const { formatSatoshisToFiat } = useSatoshisConversion();
+
+  const getFiatSuffix = (satoshis: bigint): string => {
+    const fiatValue = formatSatoshisToFiat(satoshis);
+    return fiatValue ? ` (~${fiatValue})` : '';
+  };
+
  return (
    <Box flexDirection='column'>
      <Text color={colors.text} bold>
@@ -32,6 +40,7 @@ export function InputsStep({
        <Text color={colors.textMuted}>
          Required: {formatSatoshis(requiredAmount)} +{' '}
          {formatSatoshis(fee)} fee
+          {getFiatSuffix(requiredAmount + fee)}
        </Text>
        <Text
          color={
@@ -41,10 +50,12 @@ export function InputsStep({
          }
        >
          Selected: {formatSatoshis(selectedAmount)}
+          {getFiatSuffix(selectedAmount)}
        </Text>
        {selectedAmount > requiredAmount + fee && (
          <Text color={colors.info}>
            Change: {formatSatoshis(changeAmount)}
+            {getFiatSuffix(changeAmount)}
          </Text>
        )}
      </Box>
@@ -65,6 +76,7 @@ export function InputsStep({
            return (
              <Box
                key={`${utxo.outpointTransactionHash}:${utxo.outpointIndex}`}
+                flexDirection='column'
              >
                <Text
                  color={isCursor ? colors.focus : colors.text}
@@ -75,6 +87,15 @@ export function InputsStep({
                  {formatHex(utxo.outpointTransactionHash, 12)}:
                  {utxo.outpointIndex}
                </Text>
+                {(() => {
+                  const fiatValue = formatSatoshisToFiat(utxo.valueSatoshis);
+                  if (!fiatValue) return null;
+                  return (
+                    <Text color={colors.textMuted}>
+                      {'   '}≈ {fiatValue}
+                    </Text>
+                  );
+                })()}
              </Box>
            );
          })
--- a/src/tui/screens/action-wizard/steps/ReviewStep.tsx
+++ b/src/tui/screens/action-wizard/steps/ReviewStep.tsx
@@ -1,6 +1,7 @@
 import React from 'react';
 import { Box, Text } from 'ink';
 import { colors, formatSatoshis } from '../../../theme.js';
+import { useSatoshisConversion } from '../../../hooks/useSatoshisConversion.js';
 import type { VariableInput, SelectableUTXO } from '../types.js';
 import type { XOTemplate } from '@xo-cash/types';

@@ -22,6 +23,32 @@ export function ReviewStep({
  changeAmount,
 }: ReviewStepProps): React.ReactElement {
  const selectedUtxos = availableUtxos.filter((u) => u.selected);
+  const { formatSatoshisToFiat } = useSatoshisConversion();
+
+  const getFiatSuffix = (satoshis: bigint): string => {
+    const fiatValue = formatSatoshisToFiat(satoshis);
+    return fiatValue ? ` (~${fiatValue})` : '';
+  };
+
+  const getVariableFiatSuffix = (variable: VariableInput): string => {
+    if (variable.type !== 'integer') {
+      return '';
+    }
+
+    if (variable.hint?.toLowerCase().includes('satoshi') !== true) {
+      return '';
+    }
+
+    if (!/^[-]?\d+$/.test(variable.value.trim())) {
+      return '';
+    }
+
+    try {
+      return getFiatSuffix(BigInt(variable.value));
+    } catch {
+      return '';
+    }
+  };

  return (
    <Box flexDirection='column'>
@@ -44,6 +71,7 @@ export function ReviewStep({
            <Text key={v.id} color={colors.textMuted}>
              {'  '}
              {v.name}: {v.value || '(empty)'}
+              {v.value ? getVariableFiatSuffix(v) : ''}
            </Text>
          ))}
        </Box>
@@ -62,6 +90,7 @@ export function ReviewStep({
            >
              {'  '}
              {formatSatoshis(u.valueSatoshis)}
+              {getFiatSuffix(u.valueSatoshis)}
            </Text>
          ))}
          {selectedUtxos.length > 3 && (
@@ -78,6 +107,7 @@ export function ReviewStep({
          <Text color={colors.text}>Outputs:</Text>
          <Text color={colors.textMuted}>
            {'  '}Change: {formatSatoshis(changeAmount)}
+            {getFiatSuffix(changeAmount)}
          </Text>
        </Box>
      )}
--- a/src/tui/screens/action-wizard/steps/RoleSelectStep.tsx
+++ b/src/tui/screens/action-wizard/steps/RoleSelectStep.tsx
@@ -61,13 +61,16 @@ export function RoleSelectStep({
        {availableRoles.length === 0 ? (
          <Text color={colors.textMuted}>No roles available</Text>
        ) : (
-          availableRoles.map((roleId, index) => {
+          availableRoles.map((roleId: string, index: number) => {
            const isCursor =
              selectedRoleIndex === index && focusArea === 'content';
            const roleDef = template.roles?.[roleId];
            const actionRole = action?.roles?.[roleId];
            const requirements = actionRole?.requirements;

+            const actionRequirements = action?.requirements;
+            const actionRoleRequirements = actionRole && actionRequirements && actionRequirements.participants?.find((participant) => participant.role === roleId);
+
            return (
              <Box key={roleId} flexDirection="column" marginY={0}>
                <Text
@@ -96,10 +99,10 @@ export function RoleSelectStep({
                        {'  '}
                      </Text>
                    )}
-                    {requirements.slots && requirements.slots.min > 0 && (
+                    {actionRoleRequirements && actionRoleRequirements.slots && actionRoleRequirements.slots.min > 0 && (
                      <Text color={colors.textMuted} dimColor>
-                        {requirements.slots.min} input slot
-                        {requirements.slots.min !== 1 ? 's' : ''}
+                        {actionRoleRequirements.slots.min} input slot
+                        {actionRoleRequirements.slots.min !== 1 ? 's' : ''}
                      </Text>
                    )}
                  </Box>
--- a/src/tui/screens/invitations/InvitationScreen.tsx
+++ b/src/tui/screens/invitations/InvitationScreen.tsx
@@ -17,10 +17,11 @@ import { useNavigation } from '../../hooks/useNavigation.js';
 import { useAppContext, useStatus } from '../../hooks/useAppContext.js';
 import { useBlockableInput, useIsInputCaptured } from '../../hooks/useInputLayer.js';
 import { useInvitations } from '../../hooks/useInvitations.js';
+import { useSatoshisConversion } from '../../hooks/useSatoshisConversion.js';
 import { colors, logoSmall, formatSatoshis } from '../../theme.js';
 import { copyToClipboard } from '../../utils/clipboard.js';
 import type { Invitation } from '../../../services/invitation.js';
-import type { XOTemplate } from '@xo-cash/types';
+import type { XOInvitationCommit, XOInvitationVariableValue, XOTemplate } from '@xo-cash/types';

 import {
  getInvitationState,
@@ -28,12 +29,12 @@ import {
  getInvitationInputs,
  getInvitationOutputs,
  getInvitationVariables,
-  getUserRole,
  formatInvitationListItem,
  formatInvitationId,
 } from '../../../utils/invitation-utils.js';

 import { InvitationImportFlow } from './invitation-import/InvitationImportFlow.js';
+import { compileCashAssemblyString } from '@xo-cash/engine';

 /**
 * Map state color name to theme color.
@@ -79,6 +80,29 @@ const invitationListGroups: ListGroup[] = [
  { id: 'invitations', separator: true },
 ];

+type OwnInvitationContext = {
+  entityIdentifier: string | null;
+  roleIdentifier: string | null;
+};
+
+function getRoleIdentifierFromCommits(commits: XOInvitationCommit[]): string | null {
+  for (const commit of commits) {
+    for (const input of commit.data.inputs ?? []) {
+      if (input.roleIdentifier) return input.roleIdentifier;
+    }
+
+    for (const output of commit.data.outputs ?? []) {
+      if (output.roleIdentifier) return output.roleIdentifier;
+    }
+
+    for (const variable of commit.data.variables ?? []) {
+      if (variable.roleIdentifier) return variable.roleIdentifier;
+    }
+  }
+
+  return null;
+}
+
 /**
 * Invitation Screen Component.
 */
@@ -88,6 +112,8 @@ export function InvitationScreen(): React.ReactElement {
  const { setStatus } = useStatus();

  const invitations = useInvitations();
+  const { currencyCode, formattedFiatPerBchRate, formatSatoshisToFiat } =
+    useSatoshisConversion();

  // ── UI state ─────────────────────────────────────────────────────────────
  const [selectedIndex, setSelectedIndex] = useState(0);
@@ -99,10 +125,15 @@ export function InvitationScreen(): React.ReactElement {
  // Two phases: first the ID input dialog, then the multi-step import flow.
  const [showIdDialog, setShowIdDialog] = useState(false);
  const [importingId, setImportingId] = useState<string | null>(null);
+  const [pendingImportedInvitationId, setPendingImportedInvitationId] = useState<string | null>(null);

  // ── Template cache ───────────────────────────────────────────────────────
  const [templateCache, setTemplateCache] = useState<Map<string, XOTemplate>>(new Map());
  const [selectedTemplate, setSelectedTemplate] = useState<XOTemplate | null>(null);
+  const [ownInvitationContext, setOwnInvitationContext] = useState<OwnInvitationContext>({
+    entityIdentifier: null,
+    roleIdentifier: null,
+  });

  // Check if we should open import dialog on mount
  const initialMode = navData.mode as string | undefined;
@@ -158,7 +189,7 @@ export function InvitationScreen(): React.ReactElement {
    });

    return [importItem, ...invitationItems];
-  }, [invitations, templateCache]);
+  }, [invitations.length, templateCache]);

  const selectedItem = listItems[selectedIndex];
  const selectedInvitation = selectedItem?.value ?? null;
@@ -176,6 +207,43 @@ export function InvitationScreen(): React.ReactElement {
      .then(template => setSelectedTemplate(template ?? null));
  }, [selectedInvitation, appService]);

+  /**
+   * Load the current engine entity's commits for the selected invitation.
+   */
+  useEffect(() => {
+    if (!selectedInvitation || !appService) {
+      setOwnInvitationContext({
+        entityIdentifier: null,
+        roleIdentifier: null,
+      });
+      return;
+    }
+
+    let isCurrent = true;
+
+    appService.engine.getOwnCommits(selectedInvitation.data)
+      .then((ownCommits) => {
+        if (!isCurrent) return;
+
+        setOwnInvitationContext({
+          entityIdentifier: ownCommits[0]?.entityIdentifier ?? null,
+          roleIdentifier: getRoleIdentifierFromCommits(ownCommits),
+        });
+      })
+      .catch(() => {
+        if (!isCurrent) return;
+
+        setOwnInvitationContext({
+          entityIdentifier: null,
+          roleIdentifier: null,
+        });
+      });
+
+    return () => {
+      isCurrent = false;
+    };
+  }, [selectedInvitation, appService]);
+
  // ── Import flow callbacks ──────────────────────────────────────────────

  /**
@@ -193,10 +261,30 @@ export function InvitationScreen(): React.ReactElement {
  /**
   * Import flow closed (completed or cancelled).
   */
-  const handleImportFlowClose = useCallback(() => {
+  const handleImportFlowClose = useCallback((importedInvitationId?: string) => {
+    if (importedInvitationId) {
+      setPendingImportedInvitationId(importedInvitationId);
+    }
    setImportingId(null);
  }, []);

+  /**
+   * Once imported invitation is visible in the list, select and focus it.
+   */
+  useEffect(() => {
+    if (!pendingImportedInvitationId) return;
+
+    const importedIndex = listItems.findIndex((item) => {
+      return item.value?.data.invitationIdentifier === pendingImportedInvitationId;
+    });
+
+    if (importedIndex >= 0) {
+      setSelectedIndex(importedIndex);
+      setFocusedPanel('list');
+      setPendingImportedInvitationId(null);
+    }
+  }, [pendingImportedInvitationId, listItems]);
+
  // ── Action handlers ────────────────────────────────────────────────────

  const acceptInvitation = useCallback(async () => {
@@ -327,10 +415,10 @@ export function InvitationScreen(): React.ReactElement {
      const seenLockingBytecodes = new Set<string>();

      for (const utxo of utxos) {
-        const lockingBytecodeHex = utxo.lockingBytecode
-          ? typeof utxo.lockingBytecode === 'string'
-            ? utxo.lockingBytecode
-            : Buffer.from(utxo.lockingBytecode).toString('hex')
+        const lockingBytecodeHex = utxo.scriptHash
+          ? typeof utxo.scriptHash === 'string'
+            ? utxo.scriptHash
+            : Buffer.from(utxo.scriptHash).toString('hex')
          : undefined;

        if (lockingBytecodeHex && seenLockingBytecodes.has(lockingBytecodeHex)) continue;
@@ -488,12 +576,49 @@ export function InvitationScreen(): React.ReactElement {
    const inputs = getInvitationInputs(selectedInvitation);
    const outputs = getInvitationOutputs(selectedInvitation);
    const variables = getInvitationVariables(selectedInvitation);
-
-    const userEntityId = selectedInvitation.data.commits?.[0]?.entityIdentifier ?? null;
-    const userRole = getUserRole(selectedInvitation, userEntityId);
+    const userEntityId = ownInvitationContext.entityIdentifier;
+    const userRole = ownInvitationContext.roleIdentifier;
    const roleInfoRaw = userRole && selectedTemplate?.roles?.[userRole];
    const roleInfo = roleInfoRaw && typeof roleInfoRaw === 'object' ? roleInfoRaw : null;

+    const getFiatSuffix = (satoshis: bigint): string => {
+      const fiatValue = formatSatoshisToFiat(satoshis);
+      return fiatValue ? ` (~${fiatValue})` : '';
+    };
+
+    const parseNumberishToBigInt = (value: unknown): bigint | null => {
+      if (typeof value === 'bigint') {
+        return value;
+      }
+
+      const asString = String(value).trim();
+      if (!/^[-]?\d+$/.test(asString)) {
+        return null;
+      }
+
+      try {
+        return BigInt(asString);
+      } catch {
+        return null;
+      }
+    };
+
+    const isSatoshisVariable = (variableIdentifier: string): boolean => {
+      const templateVariable = selectedTemplate?.variables?.[variableIdentifier];
+      const templateType = templateVariable?.type?.toLowerCase();
+      const templateHint = templateVariable?.hint?.toLowerCase();
+      const identifier = variableIdentifier.toLowerCase();
+
+      if (templateHint?.includes('satoshi')) {
+        return true;
+      }
+
+      return (
+        templateType === 'integer' &&
+        (identifier.includes('satoshi') || identifier.includes('amount'))
+      );
+    };
+
    return (
      <Box flexDirection="column">
        {/* Type & Status */}
@@ -514,6 +639,11 @@ export function InvitationScreen(): React.ReactElement {
              <Text color={colors.textMuted}>
                Action: {action?.name ?? selectedInvitation.data.actionIdentifier}
              </Text>
+              {formattedFiatPerBchRate && (
+                <Text color={colors.textMuted}>
+                  1 BCH = {formattedFiatPerBchRate}
+                </Text>
+              )}
              {action?.description && (
                <Text color={colors.textMuted} dimColor>{action.description}</Text>
              )}
@@ -542,14 +672,28 @@ export function InvitationScreen(): React.ReactElement {
              inputs.map((input, idx) => {
                const isUserInput = input.entityIdentifier === userEntityId;
                const inputTemplate = selectedTemplate?.inputs?.[input.inputIdentifier ?? ''];
+                const inputSatoshis = (
+                  'valueSatoshis' in input && input.valueSatoshis !== undefined
+                )
+                  ? parseNumberishToBigInt(input.valueSatoshis)
+                  : null;
                return (
                  <Text
                    key={`input-${idx}`}
                    color={isUserInput ? colors.success : colors.text}
                  >
+                    {/* Indicator for whether this is the user's input */}
                    {'  '}{isUserInput ? '• ' : '○ '}
+                    
+                    {/* TODO: Why doesnt this stuff work? It just cant resolve inputs? */}
+                    {/* Input name */}
                    {inputTemplate?.name ?? input.inputIdentifier ?? `Input ${idx}`}
+                    
+                    {/* Input role */}
                    {input.roleIdentifier && ` (${input.roleIdentifier})`}
+                    
+                    {/* Input value */}
+                    {inputSatoshis !== null && ` ${formatSatoshis(inputSatoshis)}${getFiatSuffix(inputSatoshis)}`}
                  </Text>
                );
              })
@@ -564,14 +708,28 @@ export function InvitationScreen(): React.ReactElement {
              outputs.map((output, idx) => {
                const isUserOutput = output.entityIdentifier === userEntityId;
                const outputTemplate = selectedTemplate?.outputs?.[output.outputIdentifier ?? ''];
+                const outputSatoshis = output.valueSatoshis !== undefined
+                  ? parseNumberishToBigInt(output.valueSatoshis)
+                  : null;
                return (
                  <Text
                    key={`output-${idx}`}
                    color={isUserOutput ? colors.success : colors.text}
                  >
+                    {/* Indicator for whether this is the user's output */}
                    {'  '}{isUserOutput ? '• ' : '○ '}
+
+                    {/* Output name */}
                    {outputTemplate?.name ?? output.outputIdentifier ?? `Output ${idx}`}
-                    {output.valueSatoshis !== undefined && ` (${formatSatoshis(output.valueSatoshis)})`}
+                    
+                    {/* Output description */}
+                    {outputTemplate?.description && ' - ' + compileCashAssemblyString(outputTemplate?.description ?? '', variables.reduce((acc, variable) => {
+                      acc[variable.variableIdentifier] = variable.value as XOInvitationVariableValue;
+                      return acc;
+                    }, {} as Record<string, XOInvitationVariableValue>))}
+                    
+                    {/* Output value */}
+                    {outputSatoshis !== null && ` (${formatSatoshis(outputSatoshis)}${getFiatSuffix(outputSatoshis)})`}
                  </Text>
                );
              })
@@ -591,6 +749,9 @@ export function InvitationScreen(): React.ReactElement {
              const displayValue = typeof variable.value === 'bigint'
                ? variable.value.toString()
                : String(variable.value);
+              const parsedVariableSatoshis = isSatoshisVariable(variable.variableIdentifier)
+                ? parseNumberishToBigInt(variable.value)
+                : null;
              return (
                <Text
                  key={`var-${idx}`}
@@ -598,6 +759,8 @@ export function InvitationScreen(): React.ReactElement {
                >
                  {'  '}{isUserVariable ? '• ' : '○ '}
                  {varTemplate?.name ?? variable.variableIdentifier}: {displayValue}
+                  {parsedVariableSatoshis !== null &&
+                    ` (${formatSatoshis(parsedVariableSatoshis)}${getFiatSuffix(parsedVariableSatoshis)})`}
                  {varTemplate?.description && (
                    <Text color={colors.textMuted} dimColor> - {varTemplate.description}</Text>
                  )}
--- a/src/tui/screens/invitations/invitation-import/InvitationImportFlow.tsx
+++ b/src/tui/screens/invitations/invitation-import/InvitationImportFlow.tsx
@@ -17,15 +17,15 @@ import { StepIndicator, type Step } from '../../../components/ProgressBar.js';
 import { FetchInvitationStep } from './steps/FetchInvitationStep.js';
 import { PreviewInvitationStep } from './steps/PreviewInvitationStep.js';
 import { RoleSelectStep } from './steps/RoleSelectStep.js';
+import { VariablesStep } from './steps/VariablesStep.js';
 import { InputsSelectStep } from './steps/InputsSelectStep.js';
 import { ReviewStep } from './steps/ReviewStep.js';

-import { IMPORT_STEPS, type ImportFlowProps, type SelectableUTXO } from './types.js';
+import { IMPORT_STEPS, type ImportFlowProps, type ImportStepType, type ImportVariableInput, type SelectableUTXO } from './types.js';
 import type { Invitation } from '../../../../services/invitation.js';
 import type { XOTemplate } from '@xo-cash/types';
 import { DialogWrapper } from '../../../components/Dialog.js';
 import { useInputLayer, useLayeredInput } from '../../../hooks/useInputLayer.js';
-import { InvitationBuilder } from '@xo-cash/engine';
 import { hexToBin } from '@bitauth/libauth';

 /** Default fee estimate in satoshis. */
@@ -34,6 +34,24 @@ const DEFAULT_FEE = 500n;
 /** Dust threshold — outputs below this are unspendable. */
 const DUST_THRESHOLD = 546n;

+/**
+ * Resolve the fixed index of a flow step from `IMPORT_STEPS`.
+ * We centralize this so step transitions do not rely on magic numbers.
+ */
+function getStepIndex(type: ImportStepType): number {
+  const index = IMPORT_STEPS.findIndex((step) => step.type === type);
+  if (index === -1) {
+    throw new Error(`Import step not found: ${type}`);
+  }
+  return index;
+}
+
+const PREVIEW_STEP_INDEX = getStepIndex('preview');
+const ROLE_SELECT_STEP_INDEX = getStepIndex('role-select');
+const VARIABLES_STEP_INDEX = getStepIndex('variables');
+const INPUTS_SELECT_STEP_INDEX = getStepIndex('inputs-select');
+const REVIEW_STEP_INDEX = getStepIndex('review');
+
 export function InvitationImportFlow({
  invitationId,
  mode,
@@ -46,10 +64,10 @@ export function InvitationImportFlow({
  // ── Accumulated state ────────────────────────────────────────────────────
  const [currentStep, setCurrentStep] = useState(0);
  const [invitation, setInvitation] = useState<Invitation | null>(null);
-  const [buildableInvitation, setBuildableInvitation] = useState<InvitationBuilder | null>(null);
  const [template, setTemplate] = useState<XOTemplate | null>(null);
  const [availableRoles, setAvailableRoles] = useState<string[]>([]);
  const [selectedRole, setSelectedRole] = useState<string | null>(null);
+  const [variableInputs, setVariableInputs] = useState<ImportVariableInput[]>([]);
  const [selectedInputs, setSelectedInputs] = useState<SelectableUTXO[]>([]);
  const [changeAmount, setChangeAmount] = useState(0n);
  const [requiredAmount, setRequiredAmount] = useState(0n);
@@ -79,9 +97,6 @@ export function InvitationImportFlow({
    setInvitation(inv);
    setTemplate(tmpl);

-    const builder = InvitationBuilder.fromInvitation(inv.data);
-    setBuildableInvitation(builder);
-
    try {
      const roles = await inv.getAvailableRoles();
      setAvailableRoles(roles);
@@ -89,20 +104,98 @@ export function InvitationImportFlow({
      showError(`Failed to get roles: ${err instanceof Error ? err.message : String(err)}`);
    }

-    setCurrentStep(1); // → Preview
+    setCurrentStep(PREVIEW_STEP_INDEX); // → Preview
  }, [showError]);

  /** PreviewStep completed — user reviewed the invitation state and wants to proceed. */
  const handlePreviewComplete = useCallback(() => {
-    setCurrentStep(2); // → Role Select
+    setCurrentStep(ROLE_SELECT_STEP_INDEX); // → Role Select
  }, []);

  /** RoleSelectStep completed — user picked a role. */
  const handleRoleComplete = useCallback((role: string) => {
    setSelectedRole(role);
-    setCurrentStep(3); // → Inputs Select
+
+    const action = template?.actions?.[invitation?.data.actionIdentifier ?? ""];
+    const roleRequirements = action?.roles?.[role]?.requirements?.variables ?? [];
+    const hasRequiredVariables = roleRequirements.length > 0;
+
+    if (!hasRequiredVariables) {
+      setVariableInputs([]);
+      setCurrentStep(INPUTS_SELECT_STEP_INDEX); // → Inputs Select
+      return;
+    }
+
+    const initializedVariables: ImportVariableInput[] = roleRequirements.map((variableId) => {
+      const variableDefinition = template?.variables?.[variableId];
+      return {
+        id: variableId,
+        name: variableDefinition?.name ?? variableId,
+        type: variableDefinition?.type ?? 'string',
+        hint: variableDefinition?.hint,
+        value: '',
+      };
+    });
+
+    setVariableInputs(initializedVariables);
+    setCurrentStep(VARIABLES_STEP_INDEX); // → Variables
+  }, [template, invitation]);
+
+  /** VariablesStep edited a field value. */
+  const handleVariableUpdate = useCallback((index: number, value: string) => {
+    setVariableInputs((previous) => {
+      const updated = [...previous];
+      const current = updated[index];
+      if (current) {
+        updated[index] = { ...current, value };
+      }
+      return updated;
+    });
  }, []);

+  /**
+   * Convert variable input value to its invitation payload representation.
+   * Numeric variables are persisted as bigint so they match action wizard behavior.
+   */
+  const parseVariableValue = useCallback((variable: ImportVariableInput) => {
+    const variableHint = variable.hint?.toLowerCase();
+    const isNumeric =
+      ['integer', 'number', 'satoshis'].includes(variable.type) ||
+      (variableHint !== undefined && ['satoshis', 'amount'].includes(variableHint));
+
+    if (!isNumeric) {
+      return variable.value;
+    }
+
+    return BigInt(variable.value || '0');
+  }, []);
+
+  /** VariablesStep completed — persist variables then continue to input selection. */
+  const handleVariablesComplete = useCallback(async () => {
+    if (!invitation || !selectedRole) return;
+
+    const emptyVariables = variableInputs.filter((variable) => variable.value.trim() === '');
+    if (emptyVariables.length > 0) {
+      showError(`Please enter values for: ${emptyVariables.map((variable) => variable.name).join(', ')}`);
+      return;
+    }
+
+    try {
+      await invitation.addVariables(
+        variableInputs.map((variable) => ({
+          variableIdentifier: variable.id,
+          roleIdentifier: selectedRole,
+          value: parseVariableValue(variable),
+        })),
+      );
+      setCurrentStep(INPUTS_SELECT_STEP_INDEX); // → Inputs Select
+    } catch (error) {
+      showError(
+        `Failed to add variables: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }, [invitation, selectedRole, variableInputs, parseVariableValue, showError]);
+
  /** InputsSelectStep completed — user selected UTXOs. */
  const handleInputsComplete = useCallback(async (inputs: SelectableUTXO[]) => {
    setSelectedInputs(inputs);
@@ -130,8 +223,8 @@ export function InvitationImportFlow({
      }]);
    }

-    setCurrentStep(4); // → Review
-  }, [invitation, buildableInvitation, selectedInputs]);
+    setCurrentStep(REVIEW_STEP_INDEX); // → Review
+  }, [invitation]);

  /** ReviewStep completed — invitation import is done. */
  const handleReviewComplete = useCallback(() => {
@@ -148,7 +241,7 @@ export function InvitationImportFlow({
      `Action: ${invitation?.data.actionIdentifier ?? 'Unknown'}`
    );
    setStatus('Ready');
-    onClose();
+    onClose(invitation?.data.invitationIdentifier);
  }, [selectedRole, template, invitation, showInfo, setStatus, onClose]);

  // ── Keyboard handling ────────────────────────────────────────────────────
@@ -205,6 +298,17 @@ export function InvitationImportFlow({
          />
        );

+      case 'variables':
+        return (
+          <VariablesStep
+            variables={variableInputs}
+            onUpdateVariable={handleVariableUpdate}
+            onComplete={handleVariablesComplete}
+            onCancel={handleCancel}
+            isActive={true}
+          />
+        );
+
      case 'inputs-select':
        if (!invitation || !selectedRole) return null;
        return (
--- a/src/tui/screens/invitations/invitation-import/steps/InputsSelectStep.tsx
+++ b/src/tui/screens/invitations/invitation-import/steps/InputsSelectStep.tsx
@@ -9,6 +9,7 @@
 import React, { useState, useEffect, useCallback, useRef } from 'react';
 import { Box, Text } from 'ink';
 import { colors, formatSatoshis } from '../../../../theme.js';
+import { useSatoshisConversion } from '../../../../hooks/useSatoshisConversion.js';
 import { useLayeredInput } from '../../../../hooks/useInputLayer.js';
 import type { InputsSelectStepProps, SelectableUTXO } from '../types.js';
 import { autoSelectGreedyUtxos, mapUnspentOutputsToSelectable } from '../../../../../utils/invitation-flow.js';
@@ -32,6 +33,7 @@ export function InputsSelectStep({
  const [requiredAmount, setRequiredAmount] = useState(0n);
  const [isLoading, setIsLoading] = useState(true);
  const [error, setError] = useState<string | null>(null);
+  const { formatSatoshisToFiat } = useSatoshisConversion();

  const fee = DEFAULT_FEE;

@@ -42,6 +44,11 @@ export function InputsSelectStep({
  const changeAmount = selectedAmount - requiredAmount - fee;
  const hasEnough = selectedAmount >= requiredAmount + fee;

+  const getFiatSuffix = (satoshis: bigint): string => {
+    const fiatValue = formatSatoshisToFiat(satoshis);
+    return fiatValue ? ` (~${fiatValue})` : '';
+  };
+
  /**
   * Determine the required satoshi amount from the invitation's variables.
   */
@@ -193,18 +200,32 @@ export function InputsSelectStep({
      {/* Summary bar */}
      <Box flexDirection="row" marginBottom={1}>
        <Text color={colors.primary} bold>Required: </Text>
-        <Text color={colors.text}>{formatSatoshis(requiredAmount + fee)}</Text>
+        <Text color={colors.text}>
+          {formatSatoshis(requiredAmount + fee)}
+          {getFiatSuffix(requiredAmount + fee)}
+        </Text>
        <Text color={colors.textMuted}> (amount {formatSatoshis(requiredAmount)} + fee {formatSatoshis(fee)})</Text>
      </Box>

      <Box flexDirection="row" marginBottom={1}>
        <Text color={colors.primary} bold>Selected: </Text>
-        <Text color={hasEnough ? colors.success : colors.error}>{formatSatoshis(selectedAmount)}</Text>
+        <Text color={hasEnough ? colors.success : colors.error}>
+          {formatSatoshis(selectedAmount)}
+          {getFiatSuffix(selectedAmount)}
+        </Text>
        {hasEnough && changeAmount >= DUST_THRESHOLD && (
-          <Text color={colors.textMuted}> (change: {formatSatoshis(changeAmount)})</Text>
+          <Text color={colors.textMuted}>
+            {' '}
+            (change: {formatSatoshis(changeAmount)}
+            {getFiatSuffix(changeAmount)})
+          </Text>
        )}
        {!hasEnough && (
-          <Text color={colors.error}> — need {formatSatoshis(requiredAmount + fee - selectedAmount)} more</Text>
+          <Text color={colors.error}>
+            {' '}
+            — need {formatSatoshis(requiredAmount + fee - selectedAmount)}
+            {getFiatSuffix(requiredAmount + fee - selectedAmount)} more
+          </Text>
        )}
      </Box>

@@ -216,13 +237,22 @@ export function InputsSelectStep({
        const txShort = utxo.outpointTransactionHash.slice(0, 8);

        return (
-          <Text
+          <Box
            key={`${utxo.outpointTransactionHash}:${utxo.outpointIndex}`}
-            color={isFocused ? colors.focus : utxo.selected ? colors.success : colors.text}
-            bold={isFocused}
+            flexDirection="column"
          >
-            {isFocused ? '▸ ' : '  '}{checkMark} {formatSatoshis(utxo.valueSatoshis)} ({txShort}…:{utxo.outpointIndex})
-          </Text>
+            <Text
+              color={isFocused ? colors.focus : utxo.selected ? colors.success : colors.text}
+              bold={isFocused}
+            >
+              {isFocused ? '▸ ' : '  '}{checkMark} {formatSatoshis(utxo.valueSatoshis)} ({txShort}…:{utxo.outpointIndex})
+            </Text>
+            {formatSatoshisToFiat(utxo.valueSatoshis) && (
+              <Text color={colors.textMuted}>
+                {'   '}≈ {formatSatoshisToFiat(utxo.valueSatoshis)}
+              </Text>
+            )}
+          </Box>
        );
      })}

--- a/src/tui/screens/invitations/invitation-import/steps/PreviewInvitationStep.tsx
+++ b/src/tui/screens/invitations/invitation-import/steps/PreviewInvitationStep.tsx
@@ -9,6 +9,7 @@
 import React from 'react';
 import { Box, Text } from 'ink';
 import { colors, formatSatoshis } from '../../../../theme.js';
+import { useSatoshisConversion } from '../../../../hooks/useSatoshisConversion.js';
 import { useLayeredInput } from '../../../../hooks/useInputLayer.js';
 import {
  getInvitationState,
@@ -41,6 +42,8 @@ export function PreviewInvitationStep({
  onCancel,
  isActive,
 }: PreviewStepProps): React.ReactElement {
+  const { formatSatoshisToFiat } = useSatoshisConversion();
+
  useLayeredInput('import-flow', (_input, key) => {
    if (key.return) onComplete();
    if (key.escape) onCancel();
@@ -168,11 +171,15 @@ export function PreviewInvitationStep({
          ) : (
            outputs.map((output, idx) => {
              const outputTemplate = template?.outputs?.[output.outputIdentifier ?? ''];
+              const fiatValue = output.valueSatoshis !== undefined
+                ? formatSatoshisToFiat(output.valueSatoshis)
+                : null;
              return (
                <Box key={`output-${idx}`}>
                  <Text color={colors.text}>
                    {'  '}• {outputTemplate?.name ?? output.outputIdentifier ?? `Output ${idx}`}
                    {output.valueSatoshis !== undefined && ` (${formatSatoshis(output.valueSatoshis)})`}
+                    {fiatValue && ` (~${fiatValue})`}
                  </Text>
                </Box>
              );
--- a/src/tui/screens/invitations/invitation-import/steps/ReviewStep.tsx
+++ b/src/tui/screens/invitations/invitation-import/steps/ReviewStep.tsx
@@ -10,6 +10,7 @@
 import React, { useState, useCallback } from 'react';
 import { Box, Text } from 'ink';
 import { colors, formatSatoshis } from '../../../../theme.js';
+import { useSatoshisConversion } from '../../../../hooks/useSatoshisConversion.js';
 import { useLayeredInput } from '../../../../hooks/useInputLayer.js';
 import type { ReviewStepProps, SelectableUTXO } from '../types.js';

@@ -32,6 +33,7 @@ export function ReviewStep({
 }: ReviewStepProps): React.ReactElement {
  const [isSubmitting, setIsSubmitting] = useState(false);
  const [error, setError] = useState<string | null>(null);
+  const { formatSatoshisToFiat } = useSatoshisConversion();

  const fee = DEFAULT_FEE;
  const action = template?.actions?.[invitation.data.actionIdentifier];
@@ -39,6 +41,11 @@ export function ReviewStep({
  // Compute totals from selected inputs
  const totalSelected = selectedInputs.reduce((sum, u) => sum + u.valueSatoshis, 0n);

+  const getFiatSuffix = (satoshis: bigint): string => {
+    const fiatValue = formatSatoshisToFiat(satoshis);
+    return fiatValue ? ` (~${fiatValue})` : '';
+  };
+
  /**
   * Execute the import: add inputs (with role) and optional change output.
   */
@@ -85,14 +92,34 @@ export function ReviewStep({
      <Box marginTop={1} flexDirection="column">
        <Text color={colors.primary} bold>Funding:</Text>
        <Text color={colors.text}>  • UTXOs: {selectedInputs.length}</Text>
-        <Text color={colors.text}>  • Total: {formatSatoshis(totalSelected)}</Text>
-        <Text color={colors.text}>  • Required: {formatSatoshis(requiredAmount)}</Text>
-        <Text color={colors.text}>  • Fee: {formatSatoshis(fee)}</Text>
+        <Text color={colors.text}>  • Total: {formatSatoshis(totalSelected)}{getFiatSuffix(totalSelected)}</Text>
+        <Text color={colors.text}>  • Required: {formatSatoshis(requiredAmount)}{getFiatSuffix(requiredAmount)}</Text>
+        <Text color={colors.text}>  • Fee: {formatSatoshis(fee)}{getFiatSuffix(fee)}</Text>
        {changeAmount >= DUST_THRESHOLD && (
-          <Text color={colors.text}>  • Change: {formatSatoshis(changeAmount)}</Text>
+          <Text color={colors.text}>  • Change: {formatSatoshis(changeAmount)}{getFiatSuffix(changeAmount)}</Text>
        )}
      </Box>

+      {selectedInputs.length > 0 && (
+        <Box marginTop={1} flexDirection="column">
+          <Text color={colors.primary} bold>Selected UTXOs:</Text>
+          {selectedInputs.slice(0, 3).map((utxo) => (
+            <Text
+              key={`${utxo.outpointTransactionHash}:${utxo.outpointIndex}`}
+              color={colors.textMuted}
+            >
+              {'  '}• {formatSatoshis(utxo.valueSatoshis)}
+              {getFiatSuffix(utxo.valueSatoshis)}
+            </Text>
+          ))}
+          {selectedInputs.length > 3 && (
+            <Text color={colors.textMuted}>
+              {'  '}...and {selectedInputs.length - 3} more
+            </Text>
+          )}
+        </Box>
+      )}
+
      {/* Error display */}
      {error && (
        <Box marginTop={1}>
--- a/src/tui/screens/invitations/invitation-import/steps/VariablesStep.tsx
+++ b/src/tui/screens/invitations/invitation-import/steps/VariablesStep.tsx
@@ -0,0 +1,113 @@
+/**
+ * VariablesStep — collects all required variable values for invitation import.
+ *
+ * This runs after role selection and before input selection so cashasm
+ * expressions can resolve required variables during `getSatsOut()`.
+ */
+
+import React, { useMemo, useState, useCallback } from "react";
+import { Box, Text } from "ink";
+import { colors } from "../../../../theme.js";
+import { useLayeredInput } from "../../../../hooks/useInputLayer.js";
+import { VariableInputField } from "../../../../components/VariableInputField.js";
+import type { VariablesStepProps } from "../types.js";
+
+/**
+ * Build a user-facing validation error for empty required fields.
+ */
+function validateVariables(
+  variables: VariablesStepProps["variables"],
+): string | null {
+  const empty = variables.filter((v) => v.value.trim() === "");
+  if (empty.length === 0) return null;
+  return `Please enter values for: ${empty.map((v) => v.name).join(", ")}`;
+}
+
+export function VariablesStep({
+  variables,
+  onUpdateVariable,
+  onComplete,
+  onCancel,
+  isActive,
+}: VariablesStepProps): React.ReactElement {
+  const [focusedInput, setFocusedInput] = useState(0);
+  const [validationError, setValidationError] = useState<string | null>(null);
+
+  const helpText = useMemo(() => {
+    if (variables.length === 0) {
+      return "No variables required for this role.";
+    }
+    return "Enter a value for each variable, then press Enter on the last field to continue.";
+  }, [variables.length]);
+
+  /**
+   * Move focus to next input, or finish the step if this is the last one.
+   */
+  const handleInputSubmit = useCallback(() => {
+    if (variables.length === 0) {
+      onComplete();
+      return;
+    }
+
+    if (focusedInput < variables.length - 1) {
+      setFocusedInput((prev) => prev + 1);
+      return;
+    }
+
+    const validation = validateVariables(variables);
+    setValidationError(validation);
+    if (!validation) {
+      onComplete();
+    }
+  }, [variables, focusedInput, onComplete]);
+
+  // Keyboard navigation for non-text actions.
+  useLayeredInput(
+    "import-flow",
+    (input, key) => {
+      if (key.upArrow || input === "k") {
+        setFocusedInput((prev) => Math.max(0, prev - 1));
+      } else if (key.downArrow || input === "j") {
+        setFocusedInput((prev) => Math.min(variables.length - 1, prev + 1));
+      } else if (key.escape) {
+        onCancel();
+      }
+    },
+    { isActive },
+  );
+
+  return (
+    <Box flexDirection="column">
+      <Text color={colors.primary} bold>
+        Required Variables
+      </Text>
+
+      <Box marginTop={1} flexDirection="column">
+        {variables.map((variable, index) => (
+          <VariableInputField
+            key={variable.id}
+            variable={variable}
+            index={index}
+            isFocused={focusedInput === index}
+            onChange={onUpdateVariable}
+            onSubmit={handleInputSubmit}
+            borderColor={colors.border as string}
+            focusColor={colors.primary as string}
+          />
+        ))}
+      </Box>
+
+      {validationError && (
+        <Box marginTop={1}>
+          <Text color={colors.error}>{validationError}</Text>
+        </Box>
+      )}
+
+      <Box marginTop={1}>
+        <Text color={colors.textMuted}>
+          {helpText} ↑↓: Change field • Esc: Cancel
+        </Text>
+      </Box>
+    </Box>
+  );
+}
--- a/src/tui/screens/invitations/invitation-import/types.ts
+++ b/src/tui/screens/invitations/invitation-import/types.ts
@@ -16,6 +16,7 @@ export type ImportStepType =
  | "fetch"
  | "preview"
  | "role-select"
+  | "variables"
  | "inputs-select"
  | "review";

@@ -30,6 +31,7 @@ export const IMPORT_STEPS: ImportStep[] = [
  { name: "Fetch", type: "fetch" },
  { name: "Preview", type: "preview" },
  { name: "Select Role", type: "role-select" },
+  { name: "Variables", type: "variables" },
  { name: "Select Inputs", type: "inputs-select" },
  { name: "Review", type: "review" },
 ];
@@ -81,6 +83,24 @@ export interface RoleSelectStepProps {
  isActive: boolean;
 }

+/** A single variable input required by the selected action role. */
+export interface ImportVariableInput {
+  id: string;
+  name: string;
+  type: string;
+  hint?: string;
+  value: string;
+}
+
+/** Props for VariablesStep — collects required role/action variable values. */
+export interface VariablesStepProps {
+  variables: ImportVariableInput[];
+  onUpdateVariable: (index: number, value: string) => void;
+  onComplete: () => void;
+  onCancel: () => void;
+  isActive: boolean;
+}
+
 /** Props for InputsSelectStep — lets user pick UTXOs to fund the invitation. */
 export interface InputsSelectStepProps {
  invitation: Invitation;
@@ -116,8 +136,12 @@ export interface ImportFlowProps {
  mode: ImportFlowMode;
  /** The application service — injected, not pulled from context. */
  appService: AppService;
-  /** Called when the flow completes or is cancelled. */
-  onClose: () => void;
+  /**
+   * Called when the flow completes or is cancelled.
+   * When import succeeds, the invitation identifier is provided so callers can
+   * select/focus the imported invitation in their UI.
+   */
+  onClose: (importedInvitationId?: string) => void;
  /** Display an error message to the user. */
  showError: (message: string) => void;
  /** Display an info message to the user. */
--- a/src/tui/utils/clipboard.ts
+++ b/src/tui/utils/clipboard.ts
@@ -8,6 +8,36 @@ import { promisify } from "util";

 const execAsync = promisify(exec);

+// Define a list of clipboard methods with their platform and command.
+// The platform is a function that returns true if the method is available on the current platform.
+// The command is a function that returns a promise that resolves to the result of the command.
+const clipboardMethods = {
+  pbCopy: {
+    platform: (platform: string) => platform === 'darwin',
+    command: async (text: string) => execAsync(`printf '%s' '${text}' | pbcopy`),
+  },
+  xclip: {
+    platform: (platform: string) => platform === 'linux',
+    command: async (text: string) => execAsync(`printf '%s' '${text}' | xclip -selection clipboard`),
+  },
+  xsel: {
+    platform: (platform: string) => platform === 'linux',
+    command: async (text: string) => execAsync(`printf '%s' '${text}' | xsel --clipboard --input`),
+  },
+  ssh: {
+    platform: (platform: string) => platform === 'linux',
+    command: async (text: string) => process.stdout.write(`\x1b]52;c;${Buffer.from(text, 'utf-8').toString('base64')}\x07`),
+  },
+  clip: {
+    platform: (platform: string) => platform === 'windows',
+    command: async (text: string) => execAsync(`echo|set /p="${text}" | clip`),
+  },
+  clipboardy: {
+    platform: (platform: string) => platform === 'windows',
+    command: async (text: string) => clipboardy.writeSync(text),
+  },
+}
+
 /**
 * Attempts to copy text to clipboard using multiple methods.
 * Tries native commands first (most reliable), then clipboardy as fallback.
@@ -21,46 +51,25 @@ export async function copyToClipboard(text: string): Promise<void> {
  // Escape the text for shell commands
  const escapedText = text.replace(/'/g, "'\\''");

-  // Try native commands first - they're more reliable
-  try {
-    if (platform === "darwin") {
-      // macOS - use pbcopy directly
-      await execAsync(`printf '%s' '${escapedText}' | pbcopy`);
-      return;
-    } else if (platform === "linux") {
-      // Linux - try xclip, then xsel
-      try {
-        await execAsync(
-          `printf '%s' '${escapedText}' | xclip -selection clipboard`,
-        );
-        return;
-      } catch {
-        try {
-          await execAsync(
-            `printf '%s' '${escapedText}' | xsel --clipboard --input`,
-          );
-          return;
-        } catch {
-          // Fall through to clipboardy
-        }
-      }
-    } else if (platform === "win32") {
-      // Windows - use clip.exe
-      await execAsync(`echo|set /p="${text}" | clip`);
-      return;
-    }
-  } catch {
-    // Native command failed, try clipboardy
-  }
+  const availableMethods = Object.values(clipboardMethods).filter(method => method.platform(platform));

-  // Fallback to clipboardy
-  try {
-    clipboardy.writeSync(text);
-    return;
-  } catch {
-    // clipboardy also failed
+  const errors: Error[] = [];
+
+  for (const method of availableMethods) {
+    try {
+      if (method.platform(platform)) {
+        await method.command(escapedText);
+      } else {
+        continue;
+      }
+      return;
+    } catch(error) {
+      if (error instanceof Error) {
+        errors.push(error);
+      }
+    }
  }

  // All methods failed
-  throw new Error(`Clipboard not available. Install xclip or xsel on Linux.`);
+  throw new Error(`Clipboard not available. ${errors.map(error => error.message).join('\n')}`);
 }
--- a/src/utils/history-utils.ts
+++ b/src/utils/history-utils.ts
@@ -1,7 +1,8 @@
 import type {
  HistoryItem,
-  HistoryInvitationItem,
-  HistoryUtxoItem,
+  WalletHistoryInput,
+  WalletHistoryItem,
+  WalletHistoryOutput,
 } from "../services/history.js";

 export type HistoryColorName =
@@ -13,10 +14,9 @@ export type HistoryColorName =
  | "text";

 export type HistoryRowType =
-  | "invitation"
-  | "invitation_input"
-  | "invitation_output"
-  | "utxo";
+  | "history_item"
+  | "history_input"
+  | "history_output";

 export interface HistoryDisplayRow {
  id: string;
@@ -25,8 +25,11 @@ export interface HistoryDisplayRow {
  description?: string;
  timestamp?: number;
  isNested: boolean;
-  utxo?: HistoryUtxoItem;
-  invitation?: HistoryInvitationItem;
+  valueSatoshis?: bigint;
+  reserved?: boolean;
+  input?: WalletHistoryInput;
+  output?: WalletHistoryOutput;
+  item?: WalletHistoryItem;
 }

 export function formatHistoryDate(timestamp?: number): string | undefined {
@@ -40,61 +43,68 @@ export function buildHistoryDisplayRows(
  const rows: HistoryDisplayRow[] = [];

  for (const item of items) {
-    if (item.kind === "invitation") {
-      rows.push({
-        id: item.id,
-        type: "invitation",
-        label: item.description,
-        timestamp: item.createdAtTimestamp,
-        isNested: false,
-        invitation: item,
-      });
-
-      for (const input of item.inputs) {
-        const satsPrefix =
-          input.valueSatoshis !== undefined
-            ? `${input.valueSatoshis.toLocaleString()} sats `
-            : "";
-        rows.push({
-          id: `${item.id}-input-${input.id}`,
-          type: "invitation_input",
-          label: `${satsPrefix}${input.outpoint.txid}:${input.outpoint.index}`,
-          description: input.description,
-          isNested: true,
-          utxo: input,
-          invitation: item,
-        });
-      }
-
+    const roles = item.roles.length > 0 ? item.roles.join(", ") : "unknown";
+    if (item.source === "utxo") {
      for (const output of item.outputs) {
        rows.push({
          id: `${item.id}-output-${output.id}`,
-          type: "invitation_output",
-          label:
-            output.valueSatoshis !== undefined
-              ? `${output.valueSatoshis.toLocaleString()} sats`
-              : "Output",
-          description: output.description,
-          isNested: true,
-          utxo: output,
-          invitation: item,
+          type: "history_output",
+          label: output.outpoint
+            ? `${output.outpoint.txid}:${output.outpoint.index}`
+            : output.outputIdentifier ?? "Output",
+          description: `${item.template} | ${roles} | ${output.description}`,
+          timestamp: item.createdAtTimestamp,
+          isNested: false,
+          valueSatoshis: output.valueSatoshis,
+          reserved: output.reserved,
+          output,
+          item,
        });
      }
-
      continue;
    }

    rows.push({
      id: item.id,
-      type: "utxo",
-      label:
-        item.valueSatoshis !== undefined
-          ? `${item.valueSatoshis.toLocaleString()} sats`
-          : "UTXO",
-      description: item.description,
+      type: "history_item",
+      label: `${item.template} | ${roles} | ${item.description}`,
+      description: item.action,
+      timestamp: item.createdAtTimestamp,
      isNested: false,
-      utxo: item,
+      valueSatoshis: item.valueSatoshis,
+      item,
    });
+
+    if (item.source !== "invitation") continue;
+
+    for (const input of item.inputs) {
+      rows.push({
+        id: `${item.id}-input-${input.id}`,
+        type: "history_input",
+        label: `${input.outpoint.txid}:${input.outpoint.index}`,
+        description: input.description,
+        isNested: true,
+        valueSatoshis: input.valueSatoshis,
+        input,
+        item,
+      });
+    }
+
+    for (const output of item.outputs) {
+      rows.push({
+        id: `${item.id}-output-${output.id}`,
+        type: "history_output",
+        label: output.outpoint
+          ? `${output.outpoint.txid}:${output.outpoint.index}`
+          : output.outputIdentifier ?? "Output",
+        description: output.description,
+        isNested: true,
+        valueSatoshis: output.valueSatoshis,
+        reserved: output.reserved,
+        output,
+        item,
+      });
+    }
  }

  return rows;
@@ -106,14 +116,14 @@ export function getHistoryItemColorName(
 ): HistoryColorName {
  if (isSelected) return "info";
  switch (row.type) {
-    case "invitation":
-      return "text";
-    case "invitation_input":
+    case "history_input":
      return "error";
-    case "invitation_output":
-      return "success";
-    case "utxo":
-      return row.utxo?.reserved ? "warning" : "success";
+    case "history_output":
+      return row.reserved ? "warning" : "success";
+    case "history_item":
+      if ((row.valueSatoshis ?? 0n) < 0n) return "error";
+      if ((row.valueSatoshis ?? 0n) > 0n) return "success";
+      return "text";
    default:
      return "text";
  }
--- a/src/utils/invitation-flow.ts
+++ b/src/utils/invitation-flow.ts
@@ -10,6 +10,7 @@ export interface SelectableUtxoLike {
  selected: boolean;
 }

+// TODO: Move to engine
 export const hasMissingRequirements = (missingRequirements: {
  variables?: string[];
  inputs?: string[];
@@ -32,6 +33,7 @@ export const isInvitationRequirementsComplete = async (
  return !hasMissingRequirements(missingRequirements);
 };

+// TODO: Move to engine in templates.ts
 export const resolveActionRoles = (
  template: XOTemplate | undefined,
  actionIdentifier: string | undefined,
@@ -45,11 +47,13 @@ export const resolveActionRoles = (
  const starts = template.start ?? [];
  const roleIds = starts
    .filter((entry) => entry.action === actionIdentifier)
-    .map((entry) => entry.role);
+    .map((entry) => entry.role)
+    .filter((roleId) => roleId !== undefined);

  return [...new Set(roleIds)];
 };

+// TODO: Move to engine
 export const roleRequiresInputs = (
  template: XOTemplate | undefined,
  actionIdentifier: string | undefined,
@@ -60,17 +64,11 @@ export const roleRequiresInputs = (
  if (!action) return false;

  const actionRole = action.roles?.[roleIdentifier];
-  const roleSlotsMin = actionRole?.requirements?.slots?.min ?? 0;
+  const actionRequirements = action.requirements;
+  const actionRoleRequirements = actionRole && actionRequirements && actionRequirements.participants?.find((participant) => participant.role === roleIdentifier);
+  const roleSlotsMin = actionRoleRequirements && actionRoleRequirements.slots && actionRoleRequirements.slots.min > 0 ? actionRoleRequirements.slots.min : 0;
  if (roleSlotsMin > 0) return true;

-  // Some templates specify slot/input requirements at action.requirements.roles
-  // instead of role.requirements. Respect those as well.
-  const roleRequirement = action.requirements?.roles?.find(
-    (requirement) => requirement.role === roleIdentifier,
-  );
-  const actionLevelSlotsMin = roleRequirement?.slots?.min ?? 0;
-  if (actionLevelSlotsMin > 0) return true;
-
  const transactionIdentifier = action.transaction;
  const transaction = transactionIdentifier
    ? template.transactions?.[transactionIdentifier]
@@ -80,6 +78,7 @@ export const roleRequiresInputs = (
  return (roleInputs?.length ?? 0) > 0;
 };

+
 export const getTransactionOutputIdentifier = (
  output: XOTemplateTransactionOutput,
 ): string | undefined => {
@@ -126,19 +125,19 @@ export const tryCashAddressToLockingBytecodeHex = (
  return binToHex(result.bytecode);
 };

+// Replace with libauth compiler in the engine
 export const resolveProvidedLockingBytecodeHex = (
  template: XOTemplate,
  outputIdentifier: string,
  variableValues: Record<string, string>,
 ): string | undefined => {
  const outputDefinition = template.outputs?.[outputIdentifier];
-  if (!outputDefinition || typeof outputDefinition.lockscript !== "string")
+  if (!outputDefinition || typeof outputDefinition.lockingScript !== "string") {
    return undefined;
+  }

-  const lockingScriptDefinition = (
-    template.lockingScripts as Record<string, unknown> | undefined
-  )?.[outputDefinition.lockscript] as { lockingScript?: string } | undefined;
-  const scriptIdentifier = lockingScriptDefinition?.lockingScript;
+  const lockingScriptDefinition = template.lockingScripts?.[outputDefinition.lockingScript];
+  const scriptIdentifier = lockingScriptDefinition?.lockingBytecode;
  if (!scriptIdentifier) return undefined;

  const scriptExpression = (
--- a/src/utils/logger.ts
+++ b/src/utils/logger.ts
@@ -1,50 +0,0 @@
-export class Logger {
-  constructor(
-    private readonly endpoint: string,
-    private readonly token: string,
-    private readonly path: string,
-  ) {}
-
-  send(
-    level: "log" | "error" | "warn" | "info",
-    message: string,
-    ...metadata: unknown[]
-  ) {
-    const data = {
-      level,
-      message: `${this.path}: ${message}`,
-      metadata,
-    };
-
-    fetch(`${this.endpoint}`, {
-      method: "POST",
-      body: JSON.stringify(data),
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": this.token,
-      },
-    }).catch((error) => {
-      console.error("Failed to send log to logger:", error);
-    });
-  }
-
-  log(message: string, ...metadata: unknown[]) {
-    this.send("log", message, ...metadata);
-  }
-
-  error(message: string, ...metadata: unknown[]) {
-    this.send("error", message, ...metadata);
-  }
-
-  warn(message: string, ...metadata: unknown[]) {
-    this.send("warn", message, ...metadata);
-  }
-
-  info(message: string, ...metadata: unknown[]) {
-    this.send("info", message, ...metadata);
-  }
-
-  child(path: string): Logger {
-    return new Logger(this.endpoint, this.token, `${this.path}.${path}`);
-  }
-}
--- a/src/utils/paths.ts
+++ b/src/utils/paths.ts
@@ -35,10 +35,17 @@ export function getDataDir(): string {
 }

 /**
- * File storing the last-used mnemonic reference for `-m` omission.
+ * File storing CLI settings (JSON), including the last-used mnemonic reference.
+ */
+export function getSettingsPath(): string {
+  return join(getConfigDir(), ".wallet");
+}
+
+/**
+ * @deprecated Prefer {@link getSettingsPath}.
 */
 export function getWalletConfigPath(): string {
-  return join(getConfigDir(), ".wallet");
+  return getSettingsPath();
 }

 /**
--- a/src/utils/rates/base-rates.ts
+++ b/src/utils/rates/base-rates.ts
@@ -0,0 +1,71 @@
+import { EventEmitter } from '../event-emitter.js';
+
+/**
+ * Events emitted by our Rates Adapters
+ */
+export type RatesEventMap = {
+  rateUpdated: {
+    numeratorUnitCode: string;
+    denominatorUnitCode: string;
+    price: number;
+  };
+};
+
+export abstract class BaseRates<
+  T extends RatesEventMap = RatesEventMap,
+> extends EventEmitter<T> {
+  /** Starts the given rates adapter so that it will emit events on price updates. */
+  public abstract start(): Promise<void>;
+
+  /** Stops the given rates adapter so that it will stop checking for price updates. */
+  public abstract stop(): Promise<void>;
+
+  /**
+   * List all available market products (pairs).
+   * @returns A set of strings in the format "NUMERATOR/DENOMINATOR"
+   */
+  public abstract listPairs(): Promise<Set<string>>;
+
+  // TODO: Consider whether we actually want the below.
+  //       Ideally, we will want to replace this with something like the Units class:
+  //       See: https://gitlab.com/GeneralProtocols/xo/stack/-/issues/44
+  /**
+   * Format the amount in the target currency to the correct number of decimal places.
+   *
+   * @param {number} amount - The amount to format.
+   * @param {string} targetCurrency - The target currency.
+   *
+   * @returns The formatted amount.
+   */
+  public formatCurrency(amount: number, targetCurrency: string): string {
+    const normalizedCurrency = targetCurrency.toUpperCase();
+    const minimumFractionDigitsMap: { [currency: string]: number } = {
+      AUD: 2,
+      BCH: 8,
+      USD: 2,
+    };
+    const minimumFractionDigits = minimumFractionDigitsMap[normalizedCurrency] ?? 2;
+    const maximumFractionDigits = Math.max(minimumFractionDigits, 8);
+
+    try {
+      const formatter = new Intl.NumberFormat('en-US', {
+        style: 'currency',
+        currency: normalizedCurrency,
+        currencyDisplay: 'narrowSymbol',
+        minimumFractionDigits,
+        maximumFractionDigits,
+      });
+
+      return formatter.format(amount);
+    } catch {
+      // Some numerator symbols from oracle pairs (e.g. DOGE/BCH) are not ISO-4217
+      // fiat currency codes, so Intl currency formatting will throw a RangeError.
+      // In that case we still return a human-readable formatted value.
+      const numericFormatter = new Intl.NumberFormat('en-US', {
+        minimumFractionDigits,
+        maximumFractionDigits,
+      });
+      return `${numericFormatter.format(amount)} ${normalizedCurrency}`;
+    }
+  }
+}
--- a/src/utils/rates/rates-oracles.ts
+++ b/src/utils/rates/rates-oracles.ts
@@ -0,0 +1,230 @@
+import {
+  OracleClient,
+  OracleMetadataMessage,
+  OraclePriceMessage,
+  type OracleMetadataMap,
+} from '@generalprotocols/oracle-client';
+
+import { type RatesEventMap, BaseRates } from './base-rates.js';
+import { type OffCallback } from '../event-emitter.js';
+import { SettingsService } from '../../services/settings.js';
+
+// Add the Oracle Price Message to our Events for this Adapter.
+export type RatesOracleEventMap = RatesEventMap & {
+  rateUpdated: {
+    oraclePriceMessage: OraclePriceMessage;
+  };
+};
+
+// TODO: Add RatesHistorical trait since Oracles can provide historical rates.
+export class RatesOracle extends BaseRates<RatesOracleEventMap> {
+  /**
+   * Create a new rates oracle.
+   *
+   * @param client The underlying oracle client. If not provided, a new client will be created.
+   * @returns The rates oracle.
+   */
+  static async from(
+    client?: OracleClient,
+    settings: SettingsService = new SettingsService(),
+  ) {
+    const ratesOracle = new RatesOracle(
+      client ?? (await OracleClient.from()),
+      settings,
+    );
+
+    return ratesOracle;
+  }
+
+  private client: OracleClient;
+  private settings: SettingsService;
+  private oracles: OracleMetadataMap;
+
+  private started: boolean = false;
+  private targetNumeratorUnitCode: string;
+  private targetDenominatorUnitCode: string = 'BCH';
+  private unsubscribeFromSettings: OffCallback | null = null;
+
+  private constructor(client: OracleClient, settings: SettingsService) {
+    super();
+
+    this.client = client;
+    this.settings = settings;
+    this.oracles = {};
+    this.targetNumeratorUnitCode = settings.getCurrency().toUpperCase();
+  }
+
+  /**
+   * Start the rates oracle and the underlying client.
+   */
+  async start() {
+    if (this.started) {
+      return;
+    }
+    this.started = true;
+    this.unsubscribeFromSettings = this.settings.on(
+      'settings-updated',
+      this.handleSettingsUpdated.bind(this),
+    );
+
+    // Create event listeners for the client.
+    this.client.setOnMetadataMessage(this.handleMetadataMessage.bind(this));
+    this.client.setOnPriceMessage(this.handlePriceMessage.bind(this));
+
+    // Get the metadata for the client.
+    this.oracles = await this.client.getMetadataMap();
+
+    // Start the client.
+    await this.client.start();
+
+    // Refresh the prices.
+    await this.refreshPrices();
+  }
+
+  /**
+   * Stop the rates oracle and the underlying client.
+   */
+  async stop() {
+    if (!this.started) {
+      return;
+    }
+    this.started = false;
+    this.unsubscribeFromSettings?.();
+    this.unsubscribeFromSettings = null;
+
+    // Remove event listeners by setting them to empty functions.
+    this.client.setOnMetadataMessage(() => {});
+    this.client.setOnPriceMessage(() => {});
+
+    await this.client.stop();
+  }
+
+  /**
+   * List the pairs that we are tracking.
+   *
+   * @returns A set of pairs.
+   */
+  async listPairs() {
+    // If metadata has not arrived yet but the client is running, query once so
+    // callers (like the currency picker) can still discover available pairs.
+    if (Object.keys(this.oracles).length === 0 && this.started) {
+      this.oracles = await this.client.getMetadataMap();
+    }
+
+    return new Set(
+      Object.values(this.oracles).map((oracle) => {
+        return `${oracle.SOURCE_NUMERATOR_UNIT_CODE}/${oracle.SOURCE_DENOMINATOR_UNIT_CODE}`;
+      }),
+    );
+  }
+
+  /**
+   * Get the latest prices for all the pairs and emit a rate updated event for each.
+   */
+  public async refreshPrices() {
+    const oracles = await this.client.getOracles();
+
+    // For each oracle, get the lastest dataSequence (price) message and emit a rate updated event.
+    await Promise.allSettled(
+      oracles.map(async (oracle) => {
+        try {
+          const messages = await this.client.getOracleMessages({
+            publicKey: oracle.publicKey,
+            minDataSequence: 1,
+            count: 1,
+          });
+
+          // We are only expecting a single message back. Just in case, we take the latest one.
+          const message = messages.reduce((latest, msg) => {
+            if (
+              msg instanceof OraclePriceMessage &&
+              msg.messageSequence > (latest?.messageSequence ?? 0)
+            ) {
+              return msg;
+            }
+            return latest;
+          }, messages[0]);
+
+          // If the message is a price message, handle it.
+          if (message instanceof OraclePriceMessage) {
+            this.handlePriceMessage(message);
+          }
+        } catch (error) {
+          console.error('Error refreshing prices for oracle:', oracle.publicKey, error);
+        }
+      }),
+    );
+  }
+
+  /**
+   * Update the metadata map that we use to track the pairs.
+   *
+   * @param message The metadata message.
+   */
+  private handleMetadataMessage(message: OracleMetadataMessage) {
+    this.oracles = OracleClient.updateMetadataMap(this.oracles, message);
+  }
+
+  /**
+   * Emit a rate updated event for the given pair.
+   *
+   * @param message The price message.
+   */
+  private handlePriceMessage(message: OraclePriceMessage) {
+    const oracle = this.oracles[message.toHexObject().publicKey];
+
+    // If the oracle doesn't have the required metadata, we can't use it.
+    if (
+      !oracle ||
+      !oracle.SOURCE_NUMERATOR_UNIT_CODE ||
+      !oracle.SOURCE_DENOMINATOR_UNIT_CODE ||
+      !oracle.ATTESTATION_SCALING
+    ) {
+      return;
+    }
+
+    const sourceNumeratorUnitCode = oracle.SOURCE_NUMERATOR_UNIT_CODE.toUpperCase();
+    const sourceDenominatorUnitCode = oracle.SOURCE_DENOMINATOR_UNIT_CODE.toUpperCase();
+
+    // Only emit the pair currently selected in settings.
+    if (
+      sourceNumeratorUnitCode !== this.targetNumeratorUnitCode ||
+      sourceDenominatorUnitCode !== this.targetDenominatorUnitCode
+    ) {
+      return;
+    }
+
+    // Scale the price
+    const priceValue = message.priceValue / oracle.ATTESTATION_SCALING;
+
+    this.emit('rateUpdated', {
+      numeratorUnitCode: sourceNumeratorUnitCode,
+      denominatorUnitCode: sourceDenominatorUnitCode,
+      price: priceValue,
+      oraclePriceMessage: message,
+    });
+  }
+
+  /**
+   * Tracks updates to settings and switches the actively emitted fiat pair.
+   */
+  private handleSettingsUpdated(
+    event: {
+      key: 'currency' | 'default-mnemonic';
+      value: string | undefined;
+    },
+  ) {
+    if (event.key !== 'currency' || !event.value) {
+      return;
+    }
+
+    this.targetNumeratorUnitCode = event.value.toUpperCase();
+
+    // Refresh so listeners get the latest value for the new currency quickly.
+    if (this.started) {
+      this.refreshPrices().catch((error) => {
+        console.error('Error refreshing prices after currency update:', error);
+      });
+    }
+  }
+}
--- a/src/utils/template-utils.ts
+++ b/src/utils/template-utils.ts
@@ -188,11 +188,13 @@ export function getRolesForAction(
  );

  return startEntries.map((entry) => {
-    const roleDef = template.roles?.[entry.role];
+    const roleDef = template.roles?.[entry.role || ''];
    const roleObj = typeof roleDef === "object" ? roleDef : null;
+
+    // TODO: This is ugly. Lot of conditionals. Need to take a much closer look at this.
    return {
-      roleId: entry.role,
-      name: roleObj?.name || entry.role,
+      roleId: entry.role || '',
+      name: roleObj?.name || entry.role || '',
      description: roleObj?.description,
    };
  });
--- a/tests/cli/arguments.test.ts
+++ b/tests/cli/arguments.test.ts
@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest"
+import { describe, it, expect } from "vitest";

 import { convertArgsToObject } from "../../src/cli/arguments";

@@ -11,45 +11,59 @@ const testCases = [
    },
  },
  {
-    input: ['-var-requested-satohis', '1000', '-role', 'receiver'],
+    input: ["-var-requested-satohis", "1000", "-role", "receiver"],
    expected: {
      args: [],
-      options: { "varRequestedSatohis": "1000", role: "receiver" },
+      options: { varRequestedSatohis: "1000", role: "receiver" },
    },
  },
  {
-    input: ['-o', 'output.json', '-var-requested-satohis', '1000', '-role', 'receiver'],
+    input: [
+      "-o",
+      "output.json",
+      "-var-requested-satohis",
+      "1000",
+      "-role",
+      "receiver",
+    ],
    expected: {
      args: [],
-      options: { output: "output.json", "varRequestedSatohis": "1000", role: "receiver" },
+      options: {
+        output: "output.json",
+        varRequestedSatohis: "1000",
+        role: "receiver",
+      },
    },
  },
  {
-    input: ['mnemonic', 'create', 'page', 'pencil', '-v', '-o', 'mnemonic.txt'],
+    input: ["mnemonic", "create", "page", "pencil", "-v", "-o", "mnemonic.txt"],
    expected: {
-      args: ['mnemonic', 'create', 'page', 'pencil'],
+      args: ["mnemonic", "create", "page", "pencil"],
      options: { verbose: "true", output: "mnemonic.txt" },
    },
  },
  {
-    input: ['-v', 'invitation', 'list', '-m', 'mnemonicFile'],
+    input: ["-v", "invitation", "list", "-m", "mnemonicFile"],
    expected: {
-      args: ['invitation', 'list'],
+      args: ["invitation", "list"],
      options: { verbose: "true", mnemonicFile: "mnemonicFile" },
    },
  },
  {
-    input: ['--help', 'template', 'import', 'template.json'],
+    input: ["--help", "template", "import", "template.json"],
    expected: {
-      args: ['template', 'import', 'template.json'],
+      args: ["template", "import", "template.json"],
      options: { help: "true" },
    },
  },
 ];

 describe("convertArgsToObject", () => {
-  it.each(testCases)("should split positional args from options", ({ input, expected }) => {
-    const result = convertArgsToObject(input);
-    expect(result).toEqual(expected);
-  });
+  it.each(testCases)(
+    "should split positional args from options",
+    ({ input, expected }) => {
+      const result = convertArgsToObject(input);
+      expect(result).toEqual(expected);
+    },
+  );
 });
--- a/tests/cli/commands/handler-contracts.test.ts
+++ b/tests/cli/commands/handler-contracts.test.ts
@@ -73,11 +73,19 @@ describe("command handler contracts", () => {
    const { io } = createMockIO();

    await expect(
-      handleResourceCommand(createCommandDeps(fakeApp, io), ["does-not-exist"], {}),
+      handleResourceCommand(
+        createCommandDeps(fakeApp, io),
+        ["does-not-exist"],
+        {},
+      ),
    ).rejects.toThrow(CommandError);

    try {
-      await handleResourceCommand(createCommandDeps(fakeApp, io), ["does-not-exist"], {});
+      await handleResourceCommand(
+        createCommandDeps(fakeApp, io),
+        ["does-not-exist"],
+        {},
+      );
    } catch (error) {
      expect(error).toBeInstanceOf(CommandError);
      expect((error as CommandError).event).toBe("resource.subcommand.unknown");
--- a/tests/cli/commands/invitation.test.ts
+++ b/tests/cli/commands/invitation.test.ts
@@ -11,18 +11,41 @@
 */

 import { expect, test, describe, beforeEach, afterEach } from "vitest";
-import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";

-import { addFakeResource, createMockAppService, createMockEngine, DEFAULT_SEED, randomTxHash } from "../mocks/engine";
+import {
+  addFakeResource,
+  createMockAppService,
+  createMockEngine,
+  DEFAULT_SEED,
+  randomTxHash,
+} from "../mocks/engine";
 import { type Engine } from "@xo-cash/engine";
-import { p2pkhTemplate, p2pkhTemplateIdentifier } from "../mocks/template-p2pkh";
+import {
+  p2pkhTemplate,
+  p2pkhTemplateIdentifier,
+} from "../mocks/template-p2pkh";
 import { AppService } from "../../../src/services/app";

 import { handleInvitationCommand } from "../../../src/cli/commands/invitation";
 import { CommandError, CommandPaths } from "../../../src/cli/commands/types";
-import { createCommandDeps, createMockIO, createMockPaths, expectLogs, type LogExpectation } from "../mocks/command";
+import {
+  createCommandDeps,
+  createMockIO,
+  createMockPaths,
+  expectLogs,
+  type LogExpectation,
+} from "../mocks/command";
+import { State } from "@xo-cash/state";

 // ============================================================================
 // Error Cases - Validate argument parsing and error handling
@@ -134,7 +157,8 @@ describe("invitation command - error cases", () => {
  let paths: CommandPaths;

  beforeEach(async () => {
-    engine = await createMockEngine(DEFAULT_SEED);
+    const mockEngine = await createMockEngine(DEFAULT_SEED);
+    engine = mockEngine.engine;
    await engine.importTemplate(p2pkhTemplate);
    app = await createMockAppService(engine);
    tempDir = mkdtempSync(path.join(tmpdir(), "xo-cli-invitation-errors-"));
@@ -150,7 +174,11 @@ describe("invitation command - error cases", () => {
    const { io } = createMockIO();

    try {
-      await handleInvitationCommand(createCommandDeps(app, io, paths), inputs, {});
+      await handleInvitationCommand(
+        createCommandDeps(app, io, paths),
+        inputs,
+        {},
+      );
      expect.fail("Expected command to throw");
    } catch (error) {
      expect(error).toBeInstanceOf(CommandError);
@@ -170,7 +198,8 @@ describe("invitation command - receive flow", () => {
  let paths: CommandPaths;

  beforeEach(async () => {
-    engine = await createMockEngine(DEFAULT_SEED);
+    const mockEngine = await createMockEngine(DEFAULT_SEED);
+    engine = mockEngine.engine;
    await engine.importTemplate(p2pkhTemplate);
    app = await createMockAppService(engine);
    tempDir = mkdtempSync(path.join(tmpdir(), "xo-cli-invitation-receive-"));
@@ -211,7 +240,10 @@ describe("invitation command - receive flow", () => {
      {},
    );

-    const expectedFile = path.join(tempDir, `inv-${result.invitationIdentifier}.json`);
+    const expectedFile = path.join(
+      tempDir,
+      `inv-${result.invitationIdentifier}.json`,
+    );
    expect(existsSync(expectedFile)).toBe(true);
  });

@@ -279,7 +311,8 @@ describe("invitation command - request satoshis flow", () => {
  let paths: CommandPaths;

  beforeEach(async () => {
-    engine = await createMockEngine(DEFAULT_SEED);
+    const mockEngine = await createMockEngine(DEFAULT_SEED);
+    engine = mockEngine.engine;
    await engine.importTemplate(p2pkhTemplate);
    app = await createMockAppService(engine);
    tempDir = mkdtempSync(path.join(tmpdir(), "xo-cli-invitation-request-"));
@@ -325,8 +358,12 @@ describe("invitation command - request satoshis flow", () => {
    );
    expect(invitation).toBeDefined();

-    const variables = invitation?.data.commits.flatMap((c) => c.data.variables ?? []);
-    const requestedSatoshis = variables?.find((v) => v.variableIdentifier === "requestedSatoshis");
+    const variables = invitation?.data.commits.flatMap(
+      (c) => c.data.variables ?? [],
+    );
+    const requestedSatoshis = variables?.find(
+      (v) => v.variableIdentifier === "requestedSatoshis",
+    );
    expect(requestedSatoshis).toBeDefined();
    expect(requestedSatoshis?.value).toBe("10000");
  });
@@ -347,8 +384,12 @@ describe("invitation command - request satoshis flow", () => {
      (inv) => inv.data.invitationIdentifier === result.invitationIdentifier,
    );

-    const variables = invitation?.data.commits.flatMap((c) => c.data.variables ?? []);
-    const requestedSatoshis = variables?.find((v) => v.variableIdentifier === "requestedSatoshis");
+    const variables = invitation?.data.commits.flatMap(
+      (c) => c.data.variables ?? [],
+    );
+    const requestedSatoshis = variables?.find(
+      (v) => v.variableIdentifier === "requestedSatoshis",
+    );
    expect(requestedSatoshis?.roleIdentifier).toBe("receiver");
  });
 });
@@ -359,12 +400,15 @@ describe("invitation command - request satoshis flow", () => {

 describe("invitation command - send flow with resources", () => {
  let engine: Engine;
+  let state: State;
  let app: AppService;
  let tempDir: string;
  let paths: CommandPaths;

  beforeEach(async () => {
-    engine = await createMockEngine(DEFAULT_SEED);
+    const mockEngine = await createMockEngine(DEFAULT_SEED);
+    engine = mockEngine.engine;
+    state = mockEngine.state;
    await engine.importTemplate(p2pkhTemplate);
    app = await createMockAppService(engine);
    tempDir = mkdtempSync(path.join(tmpdir(), "xo-cli-invitation-send-"));
@@ -388,7 +432,8 @@ describe("invitation command - send flow with resources", () => {
      ["create", "Wallet (P2PKH)", "sendSatoshis"],
      {
        varTransferredSatoshis: "10000",
-        varRecipientLockingscript: "76a91489abcdefabbaabbaabbaabbaabbaabbaabbaabba88ac",
+        varRecipientLockingscript:
+          "76a91489abcdefabbaabbaabbaabbaabbaabbaabbaabba88ac",
        role: "sender",
      },
    );
@@ -408,7 +453,8 @@ describe("invitation command - send flow with resources", () => {
      ["create", "Wallet (P2PKH)", "sendSatoshis"],
      {
        varTransferredSatoshis: "10000",
-        varRecipientLockingscript: "76a91489abcdefabbaabbaabbaabbaabbaabbaabbaabba88ac",
+        varRecipientLockingscript:
+          "76a91489abcdefabbaabbaabbaabbaabbaabbaabbaabba88ac",
        role: "sender",
      },
    );
@@ -418,8 +464,12 @@ describe("invitation command - send flow with resources", () => {
    );
    expect(invitation).toBeDefined();

-    const variables = invitation?.data.commits.flatMap((c) => c.data.variables ?? []);
-    const transferredSatoshis = variables?.find((v) => v.variableIdentifier === "transferredSatoshis");
+    const variables = invitation?.data.commits.flatMap(
+      (c) => c.data.variables ?? [],
+    );
+    const transferredSatoshis = variables?.find(
+      (v) => v.variableIdentifier === "transferredSatoshis",
+    );
    expect(transferredSatoshis).toBeDefined();
    expect(transferredSatoshis?.value).toBe("10000");
  });
@@ -436,8 +486,10 @@ describe("invitation command - send flow with resources", () => {
        ["create", "Wallet (P2PKH)", "sendSatoshis"],
        {
          varTransferredSatoshis: "10000",
-          varRecipientLockingscript: "76a91489abcdefabbaabbaabbaabbaabbaabbaabbaabba88ac",
-          addInput: "0000000000000000000000000000000000000000000000000000000000000000:0",
+          varRecipientLockingscript:
+            "76a91489abcdefabbaabbaabbaabbaabbaabbaabbaabba88ac",
+          addInput:
+            "0000000000000000000000000000000000000000000000000000000000000000:0",
          role: "sender",
        },
      );
@@ -452,7 +504,7 @@ describe("invitation command - send flow with resources", () => {
   * This validates our test infrastructure works correctly.
   */
  test("fake resources are accessible via engine", async () => {
-    const resource = await addFakeResource(engine, {
+    const resource = await addFakeResource(state!, {
      valueSatoshis: 50000,
      templateIdentifier: p2pkhTemplateIdentifier,
      outputIdentifier: "receiveOutput",
@@ -481,7 +533,8 @@ describe("invitation command - multi-step append", () => {
  let paths: CommandPaths;

  beforeEach(async () => {
-    engine = await createMockEngine(DEFAULT_SEED);
+    const mockEngine = await createMockEngine(DEFAULT_SEED);
+    engine = mockEngine.engine;
    await engine.importTemplate(p2pkhTemplate);
    app = await createMockAppService(engine);
    tempDir = mkdtempSync(path.join(tmpdir(), "xo-cli-invitation-append-"));
@@ -516,10 +569,15 @@ describe("invitation command - multi-step append", () => {
    expectLogs(spies, [{ out: "Invitation appended" }]);

    const invitation = app.invitations.find(
-      (inv) => inv.data.invitationIdentifier === createResult.invitationIdentifier,
+      (inv) =>
+        inv.data.invitationIdentifier === createResult.invitationIdentifier,
+    );
+    const variables = invitation?.data.commits.flatMap(
+      (c) => c.data.variables ?? [],
+    );
+    const requestedSatoshis = variables?.find(
+      (v) => v.variableIdentifier === "requestedSatoshis",
    );
-    const variables = invitation?.data.commits.flatMap((c) => c.data.variables ?? []);
-    const requestedSatoshis = variables?.find((v) => v.variableIdentifier === "requestedSatoshis");
    expect(requestedSatoshis?.value).toBe("25000");
  });

@@ -569,7 +627,10 @@ describe("invitation command - multi-step append", () => {

    expectLogs(spies, [{ out: "Invitation updated" }]);

-    const expectedFile = path.join(tempDir, `inv-${createResult.invitationIdentifier}.json`);
+    const expectedFile = path.join(
+      tempDir,
+      `inv-${createResult.invitationIdentifier}.json`,
+    );
    expect(existsSync(expectedFile)).toBe(true);
  });

@@ -594,12 +655,17 @@ describe("invitation command - multi-step append", () => {
    );

    const invitation = app.invitations.find(
-      (inv) => inv.data.invitationIdentifier === createResult.invitationIdentifier,
+      (inv) =>
+        inv.data.invitationIdentifier === createResult.invitationIdentifier,
    );
    expect(invitation?.data.commits.length).toBeGreaterThan(1);

-    const variables = invitation?.data.commits.flatMap((c) => c.data.variables ?? []);
-    const requestedSatoshis = variables?.find((v) => v.variableIdentifier === "requestedSatoshis");
+    const variables = invitation?.data.commits.flatMap(
+      (c) => c.data.variables ?? [],
+    );
+    const requestedSatoshis = variables?.find(
+      (v) => v.variableIdentifier === "requestedSatoshis",
+    );
    expect(requestedSatoshis?.value).toBe("10000");
  });
 });
@@ -615,7 +681,8 @@ describe("invitation command - list and inspect", () => {
  let paths: CommandPaths;

  beforeEach(async () => {
-    engine = await createMockEngine(DEFAULT_SEED);
+    const mockEngine = await createMockEngine(DEFAULT_SEED);
+    engine = mockEngine.engine;
    await engine.importTemplate(p2pkhTemplate);
    app = await createMockAppService(engine);
    tempDir = mkdtempSync(path.join(tmpdir(), "xo-cli-invitation-list-"));
@@ -724,7 +791,10 @@ describe("invitation command - list and inspect", () => {
      {},
    );

-    const invitationFilePath = path.join(tempDir, `inv-${createResult.invitationIdentifier}.json`);
+    const invitationFilePath = path.join(
+      tempDir,
+      `inv-${createResult.invitationIdentifier}.json`,
+    );

    const { io: inspectIO } = createMockIO();

@@ -780,7 +850,8 @@ describe("invitation command - sign flow", () => {
  let paths: CommandPaths;

  beforeEach(async () => {
-    engine = await createMockEngine(DEFAULT_SEED);
+    const mockEngine = await createMockEngine(DEFAULT_SEED);
+    engine = mockEngine.engine;
    await engine.importTemplate(p2pkhTemplate);
    app = await createMockAppService(engine);
    tempDir = mkdtempSync(path.join(tmpdir(), "xo-cli-invitation-sign-"));
@@ -813,7 +884,9 @@ describe("invitation command - sign flow", () => {
      {},
    );

-    expect(signResult.invitationIdentifier).toBe(createResult.invitationIdentifier);
+    expect(signResult.invitationIdentifier).toBe(
+      createResult.invitationIdentifier,
+    );
    expectLogs(spies, [{ out: "Invitation signed" }]);
  });

@@ -840,7 +913,8 @@ describe("invitation command - sign flow", () => {
    );

    const invitation = app.invitations.find(
-      (inv) => inv.data.invitationIdentifier === createResult.invitationIdentifier,
+      (inv) =>
+        inv.data.invitationIdentifier === createResult.invitationIdentifier,
    );

    expect(invitation).toBeDefined();
@@ -897,7 +971,8 @@ describe("invitation command - import flow", () => {
  let paths: CommandPaths;

  beforeEach(async () => {
-    engine = await createMockEngine(DEFAULT_SEED);
+    const mockEngine = await createMockEngine(DEFAULT_SEED);
+    engine = mockEngine.engine;
    await engine.importTemplate(p2pkhTemplate);
    app = await createMockAppService(engine);
    tempDir = mkdtempSync(path.join(tmpdir(), "xo-cli-invitation-import-"));
@@ -921,7 +996,10 @@ describe("invitation command - import flow", () => {
      {},
    );

-    const invitationFilePath = path.join(tempDir, `inv-${createResult.invitationIdentifier}.json`);
+    const invitationFilePath = path.join(
+      tempDir,
+      `inv-${createResult.invitationIdentifier}.json`,
+    );

    const secondApp = await createMockAppService(engine);
    const { io: importIO } = createMockIO();
@@ -965,7 +1043,10 @@ describe("invitation command - import flow", () => {
      {},
    );

-    const invitationFilePath = path.join(tempDir, `inv-${createResult.invitationIdentifier}.json`);
+    const invitationFilePath = path.join(
+      tempDir,
+      `inv-${createResult.invitationIdentifier}.json`,
+    );

    const secondApp = await createMockAppService(engine);
    const { io: importIO } = createMockIO();
@@ -991,7 +1072,10 @@ describe("invitation command - import flow", () => {
      {},
    );

-    const invitationFilePath = path.join(tempDir, `inv-${createResult.invitationIdentifier}.json`);
+    const invitationFilePath = path.join(
+      tempDir,
+      `inv-${createResult.invitationIdentifier}.json`,
+    );

    const secondApp = await createMockAppService(engine);
    const { io: importIO } = createMockIO();
@@ -1019,7 +1103,8 @@ describe("invitation command - auto-inputs flow", () => {
  let paths: CommandPaths;

  beforeEach(async () => {
-    engine = await createMockEngine(DEFAULT_SEED);
+    const mockEngine = await createMockEngine(DEFAULT_SEED);
+    engine = mockEngine.engine;
    await engine.importTemplate(p2pkhTemplate);
    app = await createMockAppService(engine);
    tempDir = mkdtempSync(path.join(tmpdir(), "xo-cli-invitation-autoinputs-"));
@@ -1044,7 +1129,8 @@ describe("invitation command - auto-inputs flow", () => {
        ["create", "Wallet (P2PKH)", "sendSatoshis"],
        {
          varTransferredSatoshis: "10000",
-          varRecipientLockingscript: "76a91489abcdefabbaabbaabbaabbaabbaabbaabbaabba88ac",
+          varRecipientLockingscript:
+            "76a91489abcdefabbaabbaabbaabbaabbaabbaabbaabba88ac",
          role: "sender",
          autoInputs: "true",
        },
@@ -1052,7 +1138,9 @@ describe("invitation command - auto-inputs flow", () => {
      expect.fail("Expected command to throw");
    } catch (error) {
      expect(error).toBeInstanceOf(CommandError);
-      expect((error as CommandError).event).toBe("invitation.create.append_params_failed");
+      expect((error as CommandError).event).toBe(
+        "invitation.create.append_params_failed",
+      );
    }
  });

@@ -1068,7 +1156,8 @@ describe("invitation command - auto-inputs flow", () => {
        ["create", "Wallet (P2PKH)", "sendSatoshis"],
        {
          varTransferredSatoshis: "10000",
-          varRecipientLockingscript: "76a91489abcdefabbaabbaabbaabbaabbaabbaabbaabba88ac",
+          varRecipientLockingscript:
+            "76a91489abcdefabbaabbaabbaabbaabbaabbaabbaabba88ac",
          role: "sender",
          autoInputs: "true",
        },
@@ -1090,7 +1179,8 @@ describe("invitation command - broadcast flow", () => {
  let paths: CommandPaths;

  beforeEach(async () => {
-    engine = await createMockEngine(DEFAULT_SEED);
+    const mockEngine = await createMockEngine(DEFAULT_SEED);
+    engine = mockEngine.engine;
    await engine.importTemplate(p2pkhTemplate);
    app = await createMockAppService(engine);
    tempDir = mkdtempSync(path.join(tmpdir(), "xo-cli-invitation-broadcast-"));
@@ -1117,7 +1207,9 @@ describe("invitation command - broadcast flow", () => {
      expect.fail("Expected command to throw");
    } catch (error) {
      expect(error).toBeInstanceOf(CommandError);
-      expect((error as CommandError).event).toBe("invitation.broadcast.not_found");
+      expect((error as CommandError).event).toBe(
+        "invitation.broadcast.not_found",
+      );
    }
  });

@@ -1152,7 +1244,8 @@ describe("invitation command - full lifecycle", () => {
  let paths: CommandPaths;

  beforeEach(async () => {
-    engine = await createMockEngine(DEFAULT_SEED);
+    const mockEngine = await createMockEngine(DEFAULT_SEED);
+    engine = mockEngine.engine;
    await engine.importTemplate(p2pkhTemplate);
    app = await createMockAppService(engine);
    tempDir = mkdtempSync(path.join(tmpdir(), "xo-cli-invitation-lifecycle-"));
@@ -1188,11 +1281,14 @@ describe("invitation command - full lifecycle", () => {
      {},
    );

-    expect(signResult.invitationIdentifier).toBe(createResult.invitationIdentifier);
+    expect(signResult.invitationIdentifier).toBe(
+      createResult.invitationIdentifier,
+    );
    expectLogs(signSpies, [{ out: "Invitation signed" }]);

    const invitation = app.invitations.find(
-      (inv) => inv.data.invitationIdentifier === createResult.invitationIdentifier,
+      (inv) =>
+        inv.data.invitationIdentifier === createResult.invitationIdentifier,
    );
    expect(invitation).toBeDefined();
    expect(invitation?.data.commits.length).toBeGreaterThan(0);
@@ -1210,7 +1306,10 @@ describe("invitation command - full lifecycle", () => {
      {},
    );

-    const invitationFilePath = path.join(tempDir, `inv-${createResult.invitationIdentifier}.json`);
+    const invitationFilePath = path.join(
+      tempDir,
+      `inv-${createResult.invitationIdentifier}.json`,
+    );
    expect(existsSync(invitationFilePath)).toBe(true);

    const { io: inspectIO } = createMockIO();
@@ -1254,7 +1353,9 @@ describe("invitation command - full lifecycle", () => {
      {},
    );

-    expect(signResult.invitationIdentifier).toBe(createResult.invitationIdentifier);
+    expect(signResult.invitationIdentifier).toBe(
+      createResult.invitationIdentifier,
+    );
    expectLogs(signSpies, [{ out: "Invitation signed" }]);
  });

@@ -1270,7 +1371,10 @@ describe("invitation command - full lifecycle", () => {
      {},
    );

-    const invitationFilePath = path.join(tempDir, `inv-${createResult.invitationIdentifier}.json`);
+    const invitationFilePath = path.join(
+      tempDir,
+      `inv-${createResult.invitationIdentifier}.json`,
+    );

    const afterCreate = JSON.parse(readFileSync(invitationFilePath, "utf-8"));
    const createCommitCount = afterCreate.commits?.length ?? 0;
@@ -1335,7 +1439,9 @@ describe("invitation command - full lifecycle", () => {
      {},
    );

-    expect(reqResult.invitationIdentifier).toBe(createResult.invitationIdentifier);
+    expect(reqResult.invitationIdentifier).toBe(
+      createResult.invitationIdentifier,
+    );
    expect(spies.out).toHaveBeenCalled();
  });
 });
--- a/tests/cli/commands/mnemonic.test.ts
+++ b/tests/cli/commands/mnemonic.test.ts
@@ -7,7 +7,12 @@ import { DEFAULT_SEED } from "../mocks/engine";

 import { handleMnemonicCommand } from "../../../src/cli/commands/mnemonic";
 import { CommandError } from "../../../src/cli/commands/types";
-import { createMockIO, createMockPaths, expectLogs, type LogExpectation } from "../mocks/command";
+import {
+  createMockIO,
+  createMockPaths,
+  expectLogs,
+  type LogExpectation,
+} from "../mocks/command";
 import { BCHMnemonicURL } from "../../../src/utils/bch-mnemonic-url";

 type TestCase = {
@@ -116,31 +121,45 @@ describe("mnemonic commands", () => {
    rmSync(tempDir, { recursive: true, force: true });
  });

-  test.each(testCases)("mnemonic command: $inputs", async ({ inputs, options, shouldThrow, expectedEvent, expectedData, logs }) => {
-    const { io, spies } = createMockIO();
-    const paths = createMockPaths(tempDir);
+  test.each(testCases)(
+    "mnemonic command: $inputs",
+    async ({
+      inputs,
+      options,
+      shouldThrow,
+      expectedEvent,
+      expectedData,
+      logs,
+    }) => {
+      const { io, spies } = createMockIO();
+      const paths = createMockPaths(tempDir);

-    if (shouldThrow) {
-      try {
-        await handleMnemonicCommand({ io, paths }, inputs, options ?? {});
-        expect.fail("Expected command to throw");
-      } catch (error) {
-        if (expectedEvent) {
-          expect(error).toBeInstanceOf(CommandError);
-          expect((error as CommandError).event).toBe(expectedEvent);
+      if (shouldThrow) {
+        try {
+          await handleMnemonicCommand({ io, paths }, inputs, options ?? {});
+          expect.fail("Expected command to throw");
+        } catch (error) {
+          if (expectedEvent) {
+            expect(error).toBeInstanceOf(CommandError);
+            expect((error as CommandError).event).toBe(expectedEvent);
+          }
+        }
+      } else {
+        const result = await handleMnemonicCommand(
+          { io, paths },
+          inputs,
+          options ?? {},
+        );
+        if (expectedData) {
+          Object.entries(expectedData).forEach(([key, value]) => {
+            expect(result[key as keyof typeof result]).toEqual(value);
+          });
        }
      }
-    } else {
-      const result = await handleMnemonicCommand({ io, paths }, inputs, options ?? {});
-      if (expectedData) {
-        Object.entries(expectedData).forEach(([key, value]) => {
-          expect(result[key as keyof typeof result]).toEqual(value);
-        });
-      }
-    }

-    if (logs) {
-      expectLogs(spies, logs);
-    }
-  });
+      if (logs) {
+        expectLogs(spies, logs);
+      }
+    },
+  );
 });
--- a/tests/cli/commands/receive.test.ts
+++ b/tests/cli/commands/receive.test.ts
@@ -3,14 +3,23 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";

-import { createMockAppService, createMockEngine, DEFAULT_SEED } from "../mocks/engine";
+import {
+  createMockAppService,
+  createMockEngine,
+  DEFAULT_SEED,
+} from "../mocks/engine";
 import { type Engine } from "@xo-cash/engine";
 import { p2pkhTemplate } from "../mocks/template-p2pkh";
 import { AppService } from "../../../src/services/app";

 import { handleReceiveCommand } from "../../../src/cli/commands/receive";
 import { CommandError } from "../../../src/cli/commands/types";
-import { createCommandDeps, createMockIO, expectLogs, type LogExpectation } from "../mocks/command";
+import {
+  createCommandDeps,
+  createMockIO,
+  expectLogs,
+  type LogExpectation,
+} from "../mocks/command";

 type TestCase = {
  name: string;
@@ -72,7 +81,8 @@ describe("receive command", () => {
  let tempDir: string;

  beforeEach(async () => {
-    engine = await createMockEngine(DEFAULT_SEED);
+    const mockEngine = await createMockEngine(DEFAULT_SEED);
+    engine = mockEngine.engine;
    await engine.importTemplate(p2pkhTemplate);

    app = await createMockAppService(engine);
@@ -85,30 +95,48 @@ describe("receive command", () => {
    rmSync(tempDir, { recursive: true, force: true });
  });

-  test.each(testCases)("$name", async ({ inputs, options, shouldThrow, expectedEvent, expectedData, logs }) => {
-    const { io, spies } = createMockIO();
+  test.each(testCases)(
+    "$name",
+    async ({
+      inputs,
+      options,
+      shouldThrow,
+      expectedEvent,
+      expectedData,
+      logs,
+    }) => {
+      const { io, spies } = createMockIO();

-    if (shouldThrow) {
-      try {
-        await handleReceiveCommand(createCommandDeps(app, io), inputs, options ?? {});
-        expect.fail("Expected command to throw");
-      } catch (error) {
-        if (expectedEvent) {
-          expect(error).toBeInstanceOf(CommandError);
-          expect((error as CommandError).event).toBe(expectedEvent);
+      if (shouldThrow) {
+        try {
+          await handleReceiveCommand(
+            createCommandDeps(app, io),
+            inputs,
+            options ?? {},
+          );
+          expect.fail("Expected command to throw");
+        } catch (error) {
+          if (expectedEvent) {
+            expect(error).toBeInstanceOf(CommandError);
+            expect((error as CommandError).event).toBe(expectedEvent);
+          }
+        }
+      } else {
+        const result = await handleReceiveCommand(
+          createCommandDeps(app, io),
+          inputs,
+          options ?? {},
+        );
+        if (expectedData) {
+          Object.entries(expectedData).forEach(([key, value]) => {
+            expect(result[key as keyof typeof result]).toEqual(value);
+          });
        }
      }
-    } else {
-      const result = await handleReceiveCommand(createCommandDeps(app, io), inputs, options ?? {});
-      if (expectedData) {
-        Object.entries(expectedData).forEach(([key, value]) => {
-          expect(result[key as keyof typeof result]).toEqual(value);
-        });
-      }
-    }

-    if (logs) {
-      expectLogs(spies, logs);
-    }
-  });
+      if (logs) {
+        expectLogs(spies, logs);
+      }
+    },
+  );
 });
--- a/tests/cli/commands/resource.test.ts
+++ b/tests/cli/commands/resource.test.ts
@@ -3,14 +3,26 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";

-import { addFakeResource, createMockAppService, createMockEngine, DEFAULT_SEED, reserveResource } from "../mocks/engine";
+import {
+  addFakeResource,
+  createMockAppService,
+  createMockEngine,
+  DEFAULT_SEED,
+  reserveResource,
+} from "../mocks/engine";
 import { type Engine } from "@xo-cash/engine";
 import { p2pkhTemplate } from "../mocks/template-p2pkh";
 import { AppService } from "../../../src/services/app";

 import { handleResourceCommand } from "../../../src/cli/commands/resource";
 import { CommandError } from "../../../src/cli/commands/types";
-import { createCommandDeps, createMockIO, expectLogs, type LogExpectation } from "../mocks/command";
+import {
+  createCommandDeps,
+  createMockIO,
+  expectLogs,
+  type LogExpectation,
+} from "../mocks/command";
+import { State } from "@xo-cash/state";

 type TestCase = {
  name: string;
@@ -94,7 +106,10 @@ const testCases: TestCase[] = [
  },
  {
    name: "throws when unreserve called with non-existent UTXO",
-    inputs: ["unreserve", "0000000000000000000000000000000000000000000000000000000000000000:0"],
+    inputs: [
+      "unreserve",
+      "0000000000000000000000000000000000000000000000000000000000000000:0",
+    ],
    shouldThrow: true,
    expectedEvent: "resource.unreserve.utxo_missing",
  },
@@ -106,7 +121,8 @@ describe("resource command", () => {
  let tempDir: string;

  beforeEach(async () => {
-    engine = await createMockEngine(DEFAULT_SEED);
+    const mockEngine = await createMockEngine(DEFAULT_SEED);
+    engine = mockEngine.engine;
    await engine.importTemplate(p2pkhTemplate);

    app = await createMockAppService(engine);
@@ -119,41 +135,62 @@ describe("resource command", () => {
    rmSync(tempDir, { recursive: true, force: true });
  });

-  test.each(testCases)("$name", async ({ inputs, options, shouldThrow, expectedEvent, expectedData, logs }) => {
-    const { io, spies } = createMockIO();
+  test.each(testCases)(
+    "$name",
+    async ({
+      inputs,
+      options,
+      shouldThrow,
+      expectedEvent,
+      expectedData,
+      logs,
+    }) => {
+      const { io, spies } = createMockIO();

-    if (shouldThrow) {
-      try {
-        await handleResourceCommand(createCommandDeps(app, io), inputs, options ?? {});
-        expect.fail("Expected command to throw");
-      } catch (error) {
-        if (expectedEvent) {
-          expect(error).toBeInstanceOf(CommandError);
-          expect((error as CommandError).event).toBe(expectedEvent);
+      if (shouldThrow) {
+        try {
+          await handleResourceCommand(
+            createCommandDeps(app, io),
+            inputs,
+            options ?? {},
+          );
+          expect.fail("Expected command to throw");
+        } catch (error) {
+          if (expectedEvent) {
+            expect(error).toBeInstanceOf(CommandError);
+            expect((error as CommandError).event).toBe(expectedEvent);
+          }
+        }
+      } else {
+        const result = await handleResourceCommand(
+          createCommandDeps(app, io),
+          inputs,
+          options ?? {},
+        );
+        if (expectedData) {
+          Object.entries(expectedData).forEach(([key, value]) => {
+            expect(result[key as keyof typeof result]).toEqual(value);
+          });
        }
      }
-    } else {
-      const result = await handleResourceCommand(createCommandDeps(app, io), inputs, options ?? {});
-      if (expectedData) {
-        Object.entries(expectedData).forEach(([key, value]) => {
-          expect(result[key as keyof typeof result]).toEqual(value);
-        });
-      }
-    }

-    if (logs) {
-      expectLogs(spies, logs);
-    }
-  });
+      if (logs) {
+        expectLogs(spies, logs);
+      }
+    },
+  );
 });

 describe("resource command with populated data", () => {
  let engine: Engine;
+  let state: State;
  let app: AppService;
  let tempDir: string;

  beforeEach(async () => {
-    engine = await createMockEngine(DEFAULT_SEED);
+    const mockEngine = await createMockEngine(DEFAULT_SEED);
+    engine = mockEngine.engine;
+    state = mockEngine.state;
    await engine.importTemplate(p2pkhTemplate);
    app = await createMockAppService(engine);
    tempDir = mkdtempSync(path.join(tmpdir(), "xo-cli-resource-tests-"));
@@ -165,19 +202,23 @@ describe("resource command with populated data", () => {
  });

  test("list returns count when resources exist", async () => {
-    await addFakeResource(engine, { valueSatoshis: 50000 });
-    await addFakeResource(engine, { valueSatoshis: 25000 });
+    await addFakeResource(state, { valueSatoshis: 50000 });
+    await addFakeResource(state, { valueSatoshis: 25000 });

    const { io, spies } = createMockIO();
-    const result = await handleResourceCommand(createCommandDeps(app, io), ["list"], {});
+    const result = await handleResourceCommand(
+      createCommandDeps(app, io),
+      ["list"],
+      {},
+    );

    expect(result.count).toBe(2);
    expectLogs(spies, [{ out: "Total resources: 2" }]);
  });

  test("list shows total satoshis", async () => {
-    await addFakeResource(engine, { valueSatoshis: 50000 });
-    await addFakeResource(engine, { valueSatoshis: 25000 });
+    await addFakeResource(state, { valueSatoshis: 50000 });
+    await addFakeResource(state, { valueSatoshis: 25000 });

    const { io, spies } = createMockIO();
    await handleResourceCommand(createCommandDeps(app, io), ["list"], {});
@@ -186,63 +227,99 @@ describe("resource command with populated data", () => {
  });

  test("list excludes reserved resources by default", async () => {
-    await addFakeResource(engine, { valueSatoshis: 50000 });
-    await addFakeResource(engine, { valueSatoshis: 25000, reservedBy: "inv-123" });
+    await addFakeResource(state, { valueSatoshis: 50000 });
+    await addFakeResource(state, {
+      valueSatoshis: 25000,
+      reservedBy: "inv-123",
+    });

    const { io } = createMockIO();
-    const result = await handleResourceCommand(createCommandDeps(app, io), ["list"], {});
+    const result = await handleResourceCommand(
+      createCommandDeps(app, io),
+      ["list"],
+      {},
+    );

    expect(result.count).toBe(1);
  });

  test("list reserved shows only reserved resources", async () => {
-    await addFakeResource(engine, { valueSatoshis: 50000 });
-    await addFakeResource(engine, { valueSatoshis: 25000, reservedBy: "inv-123" });
-    await addFakeResource(engine, { valueSatoshis: 10000, reservedBy: "inv-456" });
+    await addFakeResource(state, { valueSatoshis: 50000 });
+    await addFakeResource(state, {
+      valueSatoshis: 25000,
+      reservedBy: "inv-123",
+    });
+    await addFakeResource(state, {
+      valueSatoshis: 10000,
+      reservedBy: "inv-456",
+    });

    const { io, spies } = createMockIO();
-    const result = await handleResourceCommand(createCommandDeps(app, io), ["list", "reserved"], {});
+    const result = await handleResourceCommand(
+      createCommandDeps(app, io),
+      ["list", "reserved"],
+      {},
+    );

    expect(result.count).toBe(2);
    expectLogs(spies, [{ out: "reserved for inv-123" }]);
  });

  test("list all shows both reserved and unreserved", async () => {
-    await addFakeResource(engine, { valueSatoshis: 50000 });
-    await addFakeResource(engine, { valueSatoshis: 25000, reservedBy: "inv-123" });
+    await addFakeResource(state, { valueSatoshis: 50000 });
+    await addFakeResource(state, {
+      valueSatoshis: 25000,
+      reservedBy: "inv-123",
+    });

    const { io } = createMockIO();
-    const result = await handleResourceCommand(createCommandDeps(app, io), ["list", "all"], {});
+    const result = await handleResourceCommand(
+      createCommandDeps(app, io),
+      ["list", "all"],
+      {},
+    );

    expect(result.count).toBe(2);
  });

  test("unreserve releases a reserved UTXO", async () => {
-    const resource = await addFakeResource(engine, { valueSatoshis: 25000, reservedBy: "inv-123" });
+    const resource = await addFakeResource(state, {
+      valueSatoshis: 25000,
+      reservedBy: "inv-123",
+    });

    const { io, spies } = createMockIO();
    await handleResourceCommand(
      createCommandDeps(app, io),
-      ["unreserve", `${resource.outpointTransactionHash}:${resource.outpointIndex}`],
+      [
+        "unreserve",
+        `${resource.outpointTransactionHash}:${resource.outpointIndex}`,
+      ],
      {},
    );

-    expectLogs(spies, [{ out: "Unreserved" }, { out: "was reserved for inv-123" }]);
+    expectLogs(spies, [
+      { out: "Unreserved" },
+      { out: "was reserved for inv-123" },
+    ]);

    const resources = await engine.listUnspentOutputsData();
    const target = resources.find(
-      r => r.outpointTransactionHash === resource.outpointTransactionHash,
+      (r) => r.outpointTransactionHash === resource.outpointTransactionHash,
    );
    expect(target?.reservedBy).toBeUndefined();
  });

  test("unreserve reports when UTXO is not reserved", async () => {
-    const resource = await addFakeResource(engine, { valueSatoshis: 25000 });
+    const resource = await addFakeResource(state, { valueSatoshis: 25000 });

    const { io, spies } = createMockIO();
    await handleResourceCommand(
      createCommandDeps(app, io),
-      ["unreserve", `${resource.outpointTransactionHash}:${resource.outpointIndex}`],
+      [
+        "unreserve",
+        `${resource.outpointTransactionHash}:${resource.outpointIndex}`,
+      ],
      {},
    );

@@ -250,23 +327,33 @@ describe("resource command with populated data", () => {
  });

  test("unreserve-all releases all reserved UTXOs", async () => {
-    await addFakeResource(engine, { valueSatoshis: 50000 });
-    await addFakeResource(engine, { valueSatoshis: 25000, reservedBy: "inv-123" });
-    await addFakeResource(engine, { valueSatoshis: 10000, reservedBy: "inv-456" });
+    await addFakeResource(state, { valueSatoshis: 50000 });
+    await addFakeResource(state, {
+      valueSatoshis: 25000,
+      reservedBy: "inv-123",
+    });
+    await addFakeResource(state, {
+      valueSatoshis: 10000,
+      reservedBy: "inv-456",
+    });

    const { io, spies } = createMockIO();
-    const result = await handleResourceCommand(createCommandDeps(app, io), ["unreserve-all"], {});
+    const result = await handleResourceCommand(
+      createCommandDeps(app, io),
+      ["unreserve-all"],
+      {},
+    );

    expect(result.count).toBe(2);
    expectLogs(spies, [{ out: "Unreserved" }, { out: "2" }]);

    const resources = await engine.listUnspentOutputsData();
-    const reserved = resources.filter(r => r.reservedBy);
+    const reserved = resources.filter((r) => r.reservedBy);
    expect(reserved).toHaveLength(0);
  });

  test("list displays outpoint information", async () => {
-    const resource = await addFakeResource(engine, { valueSatoshis: 12345 });
+    const resource = await addFakeResource(state, { valueSatoshis: 12345 });

    const { io, spies } = createMockIO();
    await handleResourceCommand(createCommandDeps(app, io), ["list"], {});
--- a/tests/cli/commands/settings.test.ts
+++ b/tests/cli/commands/settings.test.ts
@@ -0,0 +1,83 @@
+/// <reference types="node" />
+
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+import { handleSettingsCommand } from "../../../src/cli/commands/settings";
+import { CommandError } from "../../../src/cli/commands/types";
+import { createMockIO, createMockPaths } from "../mocks/command";
+
+describe("settings command", () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(path.join(tmpdir(), "xo-cli-settings-command-test-"));
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  test("shows default settings when .wallet does not exist", async () => {
+    const { io, capture } = createMockIO();
+    const paths = createMockPaths(tempDir);
+
+    const result = await handleSettingsCommand({ io, paths }, ["show"], {});
+
+    expect(result).toEqual({ currency: "USD" });
+    expect(capture.out.join("\n")).toContain("currency");
+    expect(capture.out.join("\n")).toContain("USD");
+  });
+
+  test("sets and gets currency", async () => {
+    const { io, capture } = createMockIO();
+    const paths = createMockPaths(tempDir);
+
+    await handleSettingsCommand({ io, paths }, ["set", "currency", "aud"], {});
+    const getResult = await handleSettingsCommand(
+      { io, paths },
+      ["get", "currency"],
+      {},
+    );
+
+    expect(getResult).toEqual({ key: "currency", value: "AUD" });
+    expect(capture.out).toContain("Updated currency: AUD");
+    expect(capture.out).toContain("AUD");
+  });
+
+  test("sets default-mnemonic and persists JSON .wallet", async () => {
+    const { io } = createMockIO();
+    const paths = createMockPaths(tempDir);
+
+    await handleSettingsCommand(
+      { io, paths },
+      ["set", "default-mnemonic", "mnemonic-primary"],
+      {},
+    );
+
+    const persisted = JSON.parse(readFileSync(paths.walletConfigPath, "utf8")) as {
+      currency: string;
+      "default-mnemonic"?: string;
+    };
+
+    expect(persisted).toEqual({
+      currency: "USD",
+      "default-mnemonic": "mnemonic-primary",
+    });
+  });
+
+  test("throws command error for unknown subcommand", async () => {
+    const { io } = createMockIO();
+    const paths = createMockPaths(tempDir);
+
+    try {
+      await handleSettingsCommand({ io, paths }, ["unknown"], {});
+      expect.fail("Expected settings command to throw");
+    } catch (error) {
+      expect(error).toBeInstanceOf(CommandError);
+      expect((error as CommandError).event).toBe("settings.subcommand.unknown");
+    }
+  });
+});
--- a/tests/cli/commands/template.test.ts
+++ b/tests/cli/commands/template.test.ts
@@ -3,14 +3,26 @@ import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";

-import { createMockAppService, createMockEngine, DEFAULT_SEED } from "../mocks/engine";
+import {
+  createMockAppService,
+  createMockEngine,
+  DEFAULT_SEED,
+} from "../mocks/engine";
 import { type Engine } from "@xo-cash/engine";
-import { p2pkhTemplate, p2pkhTemplateIdentifier } from "../mocks/template-p2pkh";
+import {
+  p2pkhTemplate,
+  p2pkhTemplateIdentifier,
+} from "../mocks/template-p2pkh";
 import { AppService } from "../../../src/services/app";

 import { handleTemplateCommand } from "../../../src/cli/commands/template";
 import { CommandError } from "../../../src/cli/commands/types";
-import { createCommandDeps, createMockIO, expectLogs, type LogExpectation } from "../mocks/command";
+import {
+  createCommandDeps,
+  createMockIO,
+  expectLogs,
+  type LogExpectation,
+} from "../mocks/command";

 type TestCase = {
  name: string;
@@ -171,7 +183,8 @@ describe("template command", () => {
  let tempDir: string;

  beforeEach(async () => {
-    engine = await createMockEngine(DEFAULT_SEED);
+    const mockEngine = await createMockEngine(DEFAULT_SEED);
+    engine = mockEngine.engine;
    await engine.importTemplate(p2pkhTemplate);

    app = await createMockAppService(engine);
@@ -184,32 +197,50 @@ describe("template command", () => {
    rmSync(tempDir, { recursive: true, force: true });
  });

-  test.each(testCases)("$name", async ({ inputs, options, shouldThrow, expectedEvent, expectedData, logs }) => {
-    const { io, spies } = createMockIO();
+  test.each(testCases)(
+    "$name",
+    async ({
+      inputs,
+      options,
+      shouldThrow,
+      expectedEvent,
+      expectedData,
+      logs,
+    }) => {
+      const { io, spies } = createMockIO();

-    if (shouldThrow) {
-      try {
-        await handleTemplateCommand(createCommandDeps(app, io), inputs, options ?? {});
-        expect.fail("Expected command to throw");
-      } catch (error) {
-        if (expectedEvent) {
-          expect(error).toBeInstanceOf(CommandError);
-          expect((error as CommandError).event).toBe(expectedEvent);
+      if (shouldThrow) {
+        try {
+          await handleTemplateCommand(
+            createCommandDeps(app, io),
+            inputs,
+            options ?? {},
+          );
+          expect.fail("Expected command to throw");
+        } catch (error) {
+          if (expectedEvent) {
+            expect(error).toBeInstanceOf(CommandError);
+            expect((error as CommandError).event).toBe(expectedEvent);
+          }
+        }
+      } else {
+        const result = await handleTemplateCommand(
+          createCommandDeps(app, io),
+          inputs,
+          options ?? {},
+        );
+        if (expectedData) {
+          Object.entries(expectedData).forEach(([key, value]) => {
+            expect(result[key as keyof typeof result]).toEqual(value);
+          });
        }
      }
-    } else {
-      const result = await handleTemplateCommand(createCommandDeps(app, io), inputs, options ?? {});
-      if (expectedData) {
-        Object.entries(expectedData).forEach(([key, value]) => {
-          expect(result[key as keyof typeof result]).toEqual(value);
-        });
-      }
-    }

-    if (logs) {
-      expectLogs(spies, logs);
-    }
-  });
+      if (logs) {
+        expectLogs(spies, logs);
+      }
+    },
+  );

  test("import imports template from file", async () => {
    const templatePath = path.join(tempDir, "test-template.json");
--- a/tests/cli/mnemonic.test.ts
+++ b/tests/cli/mnemonic.test.ts
@@ -1,5 +1,11 @@
 import { expect, test, describe, beforeEach, afterEach } from "vitest";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";

@@ -12,7 +18,8 @@ import {
 } from "../../src/cli/mnemonic";
 import { BCHMnemonicURL } from "../../src/utils/bch-mnemonic-url";

-const TEST_SEED = "page pencil stock planet limb cluster assault speak off joke private pioneer";
+const TEST_SEED =
+  "page pencil stock planet limb cluster assault speak off joke private pioneer";

 describe("mnemonic utilities", () => {
  let tempDir: string;
@@ -68,7 +75,11 @@ describe("mnemonic utilities", () => {
    });

    test("sanitizes filename to basename only", () => {
-      const filename = createMnemonicFile(tempDir, TEST_SEED, "../../../evil-path");
+      const filename = createMnemonicFile(
+        tempDir,
+        TEST_SEED,
+        "../../../evil-path",
+      );

      expect(filename).toBe("evil-path");
      expect(existsSync(path.join(tempDir, "evil-path"))).toBe(true);
@@ -95,7 +106,10 @@ describe("mnemonic utilities", () => {

      try {
        writeFileSync(path.join(tempDir, "mnemonic-relative"), "test");
-        const resolved = resolveMnemonicFilePath("/nonexistent", "mnemonic-relative");
+        const resolved = resolveMnemonicFilePath(
+          "/nonexistent",
+          "mnemonic-relative",
+        );
        expect(resolved).toBe(path.join(tempDir, "mnemonic-relative"));
      } finally {
        process.chdir(originalCwd);
@@ -110,15 +124,18 @@ describe("mnemonic utilities", () => {
    });

    test("throws when file not found anywhere", () => {
-      expect(() => resolveMnemonicFilePath(tempDir, "nonexistent-file")).toThrow(
-        /Mnemonic file not found/,
-      );
+      expect(() =>
+        resolveMnemonicFilePath(tempDir, "nonexistent-file"),
+      ).toThrow(/Mnemonic file not found/);
    });

    test("strips path components and looks up basename in mnemonicsDir", () => {
      writeFileSync(path.join(tempDir, "mnemonic-basename"), "test");

-      const resolved = resolveMnemonicFilePath(tempDir, "some/path/mnemonic-basename");
+      const resolved = resolveMnemonicFilePath(
+        tempDir,
+        "some/path/mnemonic-basename",
+      );
      expect(resolved).toBe(path.join(tempDir, "mnemonic-basename"));
    });
  });
@@ -140,11 +157,16 @@ describe("mnemonic utilities", () => {
    });

    test("throws when file not found", () => {
-      expect(() => loadMnemonic(tempDir, "nonexistent")).toThrow(/Mnemonic file not found/);
+      expect(() => loadMnemonic(tempDir, "nonexistent")).toThrow(
+        /Mnemonic file not found/,
+      );
    });

    test("throws when file contains invalid data", () => {
-      writeFileSync(path.join(tempDir, "mnemonic-invalid"), "not a valid mnemonic url");
+      writeFileSync(
+        path.join(tempDir, "mnemonic-invalid"),
+        "not a valid mnemonic url",
+      );

      expect(() => loadMnemonic(tempDir, "mnemonic-invalid")).toThrow();
    });
--- a/tests/cli/mocks/command.ts
+++ b/tests/cli/mocks/command.ts
@@ -92,27 +92,36 @@ export const createMockIO = (): MockIO => {
 * @param spies - The mock IO spies from createMockIO
 * @param logs - Array of log expectations to validate
 */
-export const expectLogs = (spies: MockIOSpies, logs: LogExpectation[]): void => {
+export const expectLogs = (
+  spies: MockIOSpies,
+  logs: LogExpectation[],
+): void => {
  for (const log of logs) {
    if (log.out !== undefined) {
      if (log.exact) {
        expect(spies.out).toHaveBeenCalledWith(log.out);
      } else {
-        expect(spies.out).toHaveBeenCalledWith(expect.stringContaining(log.out));
+        expect(spies.out).toHaveBeenCalledWith(
+          expect.stringContaining(log.out),
+        );
      }
    }
    if (log.err !== undefined) {
      if (log.exact) {
        expect(spies.err).toHaveBeenCalledWith(log.err);
      } else {
-        expect(spies.err).toHaveBeenCalledWith(expect.stringContaining(log.err));
+        expect(spies.err).toHaveBeenCalledWith(
+          expect.stringContaining(log.err),
+        );
      }
    }
    if (log.verbose !== undefined) {
      if (log.exact) {
        expect(spies.verbose).toHaveBeenCalledWith(log.verbose);
      } else {
-        expect(spies.verbose).toHaveBeenCalledWith(expect.stringContaining(log.verbose));
+        expect(spies.verbose).toHaveBeenCalledWith(
+          expect.stringContaining(log.verbose),
+        );
      }
    }
  }
--- a/tests/cli/mocks/electrum-service.ts
+++ b/tests/cli/mocks/electrum-service.ts
@@ -1,3 +1,8 @@
+/**
+ * Mock Electrum service for testing.
+ * NOTE & TODO: Do we even need this in the actual app? I forget why we had this, but it seems like its just overly complicating things
+ *              And we end up in stupid situations where we are creating a mock for a single function class.
+ */
 export class MockElectrumService {
  constructor() {}

--- a/tests/cli/mocks/engine.ts
+++ b/tests/cli/mocks/engine.ts
@@ -1,6 +1,12 @@
 import { BlockchainMonitor, Engine } from "@xo-cash/engine";

-import { createStorageAdapter, State, StorageType, type UnspentOutputData } from "@xo-cash/state";
+import {
+  createStorageAdapter,
+  State,
+  StorageType,
+  UnspentOutputStatus,
+  type UnspentOutputData,
+} from "@xo-cash/state";
 import { InMemoryBlockchainProvider } from "@xo-cash/engine";
 import { convertMnemonicToSeedBytes } from "@xo-cash/crypto";

@@ -8,8 +14,11 @@ import { binToHex, sha256 } from "@bitauth/libauth";
 import { AppService } from "../../../src/services/app";
 import { InMemoryStorage } from "../../../src/services/storage";
 import { MockElectrumService } from "./electrum-service";
+import { MockRatesService } from "./rates-service";
+import { RatesService } from "../../../src/services/rates";

-export const DEFAULT_SEED = "page pencil stock planet limb cluster assault speak off joke private pioneer";
+export const DEFAULT_SEED =
+  "page pencil stock planet limb cluster assault speak off joke private pioneer";

 /**
 * Options for creating a fake resource (UTXO) in tests.
@@ -39,7 +48,9 @@ export type FakeResourceOptions = {
 export const randomTxHash = (): string => {
  const bytes = new Uint8Array(32);
  crypto.getRandomValues(bytes);
-  return Array.from(bytes).map(b => b.toString(16).padStart(2, "0")).join("");
+  return Array.from(bytes)
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
 };

 /**
@@ -49,11 +60,11 @@ export const randomTxHash = (): string => {
 * @returns The created UnspentOutputData object.
 */
 export const addFakeResource = async (
-  engine: Engine,
+  state: State,
  options: FakeResourceOptions = {},
 ): Promise<UnspentOutputData> => {
  const resource: UnspentOutputData = {
-    status: "confirmed",
+    status: UnspentOutputStatus.CONFIRMED,
    selectable: true,
    privacy: false,
    templateIdentifier: options.templateIdentifier ?? "test-template",
@@ -62,11 +73,13 @@ export const addFakeResource = async (
    outpointTransactionHash: options.outpointTransactionHash ?? randomTxHash(),
    minedAtHeight: options.minedAtHeight ?? 800000,
    valueSatoshis: options.valueSatoshis ?? 10000,
-    lockingBytecode: options.lockingBytecode ?? "76a914000000000000000000000000000000000000000088ac",
+    scriptHash:
+      options.lockingBytecode ??
+      "76a914000000000000000000000000000000000000000088ac",
    reservedBy: options.reservedBy,
  };

-  await engine.state.storeUnspentOutputData(resource);
+  await state.storeUnspentOutputData(resource);
  return resource;
 };

@@ -78,12 +91,12 @@ export const addFakeResource = async (
 * @param invitationIdentifier - The invitation identifier to reserve for.
 */
 export const reserveResource = async (
-  engine: Engine,
+  state: State,
  outpointTransactionHash: string,
  outpointIndex: number,
  invitationIdentifier: string,
 ): Promise<void> => {
-  await engine.state.executeBulkUnspentOutputReservation(
+  await state.executeBulkUnspentOutputReservation(
    [{ outpointTransactionHash, outpointIndex }],
    true,
    invitationIdentifier,
@@ -98,12 +111,12 @@ export const reserveResource = async (
 * @param invitationIdentifier - The invitation identifier to unreserve from.
 */
 export const unreserveResource = async (
-  engine: Engine,
+  state: State,
  outpointTransactionHash: string,
  outpointIndex: number,
  invitationIdentifier: string,
 ): Promise<void> => {
-  await engine.state.executeBulkUnspentOutputReservation(
+  await state.executeBulkUnspentOutputReservation(
    [{ outpointTransactionHash, outpointIndex }],
    false,
    invitationIdentifier,
@@ -118,7 +131,7 @@ export const unreserveResource = async (
 export const createMockEngine = async (seed: string) => {
  // Create the in-memory storage adapter.
  const storage = await createStorageAdapter({
-    storageType: StorageType.INMEMORY,
+    storageType: "inmemory",
    accountHash: binToHex(sha256.hash(convertMnemonicToSeedBytes(seed))),
  });

@@ -143,13 +156,16 @@ export const createMockEngine = async (seed: string) => {
  const engine = new Engine(seed, state, blockchainMonitor, blockchainProvider);
  await engine.initializeStateSync();

-  return engine;
+  return { engine, state, blockchainMonitor, blockchainProvider };
 };

 export const createMockAppService = async (engine: Engine) => {
  const storage = await InMemoryStorage.create();

-  const electrum = new MockElectrumService();
+  const mockRates = new MockRatesService();
+  const rates = new RatesService(mockRates);
+
+  const mockElectrum = new MockElectrumService();

  const config = {
    syncServerUrl: "http://localhost:3000",
@@ -160,5 +176,5 @@ export const createMockAppService = async (engine: Engine) => {
    invitationStoragePath: "test-invitations.db",
  };

-  return new AppService(engine, storage, config, electrum);
+  return new AppService(engine, storage, config, mockElectrum, rates);
 };
--- a/tests/cli/mocks/rates-service.ts
+++ b/tests/cli/mocks/rates-service.ts
@@ -0,0 +1,23 @@
+import { BaseRates } from "../../../src/utils/rates/base-rates";
+
+export class MockRatesService extends BaseRates {
+  constructor() {
+    super();
+  }
+
+  async getRate(numeratorUnitCode: string, denominatorUnitCode: string): Promise<number> {
+    return 1;
+  }
+
+  async start(): Promise<void> {
+    return;
+  }
+
+  async stop(): Promise<void> {
+    return;
+  }
+
+  async listPairs(): Promise<Set<string>> {
+    return new Set();
+  }
+}
--- a/tests/cli/mocks/template-p2pkh.ts
+++ b/tests/cli/mocks/template-p2pkh.ts
--- a/tests/cli/paths.test.ts
+++ b/tests/cli/paths.test.ts
@@ -30,7 +30,9 @@ describe("paths utilities", () => {
    test("returns path under config dir", () => {
      const mnemonicsDir = getMnemonicsDir();

-      expect(mnemonicsDir).toBe(path.join(homedir(), ".config", "xo-cli", "mnemonics"));
+      expect(mnemonicsDir).toBe(
+        path.join(homedir(), ".config", "xo-cli", "mnemonics"),
+      );
    });

    test("creates the directory if it does not exist", () => {
@@ -58,7 +60,9 @@ describe("paths utilities", () => {
    test("returns .wallet file path under config dir", () => {
      const walletConfigPath = getWalletConfigPath();

-      expect(walletConfigPath).toBe(path.join(homedir(), ".config", "xo-cli", ".wallet"));
+      expect(walletConfigPath).toBe(
+        path.join(homedir(), ".config", "xo-cli", ".wallet"),
+      );
    });
  });

@@ -111,9 +115,9 @@ describe("paths utilities", () => {
    });

    test("throws when file not found anywhere", () => {
-      expect(() => resolveMnemonicFilePath("nonexistent-mnemonic-file-xyz")).toThrow(
-        /Mnemonic file not found/,
-      );
+      expect(() =>
+        resolveMnemonicFilePath("nonexistent-mnemonic-file-xyz"),
+      ).toThrow(/Mnemonic file not found/);
    });

    test("does not resolve absolute path if file does not exist", () => {
--- a/tests/cli/rates-format.test.ts
+++ b/tests/cli/rates-format.test.ts
@@ -0,0 +1,40 @@
+/// <reference types="node" />
+
+import { describe, expect, test } from "vitest";
+
+import { BaseRates } from "../../src/utils/rates/base-rates";
+
+/**
+ * Minimal concrete adapter used only for testing BaseRates helpers.
+ */
+class TestRatesAdapter extends BaseRates {
+  public async start(): Promise<void> {
+    return;
+  }
+
+  public async stop(): Promise<void> {
+    return;
+  }
+
+  public async listPairs(): Promise<Set<string>> {
+    return new Set(["USD/BCH", "DOGE/BCH"]);
+  }
+}
+
+describe("BaseRates.formatCurrency", () => {
+  test("formats ISO currency codes with Intl currency style", () => {
+    const rates = new TestRatesAdapter();
+    const formatted = rates.formatCurrency(12.5, "USD");
+
+    expect(formatted).toContain("$");
+    expect(formatted).toContain("12.50");
+  });
+
+  test("formats non-ISO symbols without throwing", () => {
+    const rates = new TestRatesAdapter();
+    const formatted = rates.formatCurrency(12.3456789, "DOGE");
+
+    expect(formatted).toContain("DOGE");
+    expect(formatted).toContain("12.3456789");
+  });
+});
--- a/tests/cli/settings.test.ts
+++ b/tests/cli/settings.test.ts
@@ -0,0 +1,96 @@
+/// <reference types="node" />
+
+import { beforeEach, afterEach, describe, expect, test } from "vitest";
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { SettingsService } from "../../src/services/settings";
+
+/**
+ * Tests for SettingsService persistence and migration behavior.
+ */
+describe("SettingsService", () => {
+  let testDir: string;
+  let settingsPath: string;
+
+  beforeEach(() => {
+    testDir = mkdtempSync(join(tmpdir(), "xo-cli-settings-test-"));
+    settingsPath = join(testDir, ".wallet");
+  });
+
+  afterEach(() => {
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  test("returns defaults when settings file does not exist", () => {
+    const settings = new SettingsService(settingsPath);
+
+    expect(settings.getDefaultMnemonic()).toBeUndefined();
+    expect(settings.getCurrency()).toBe("USD");
+    expect(settings.getSettings()).toEqual({ currency: "USD" });
+    expect(existsSync(settingsPath)).toBe(false);
+  });
+
+  test("migrates legacy .wallet plaintext mnemonic to JSON", () => {
+    writeFileSync(settingsPath, "mnemonic-legacy", "utf8");
+
+    const settings = new SettingsService(settingsPath);
+
+    expect(settings.getDefaultMnemonic()).toBe("mnemonic-legacy");
+    expect(settings.getCurrency()).toBe("USD");
+
+    const persisted = JSON.parse(readFileSync(settingsPath, "utf8")) as {
+      "default-mnemonic"?: string;
+      currency: string;
+    };
+    expect(persisted).toEqual({
+      "default-mnemonic": "mnemonic-legacy",
+      currency: "USD",
+    });
+  });
+
+  test("normalizes and persists currency and default-mnemonic", () => {
+    const settings = new SettingsService(settingsPath);
+
+    settings.setDefaultMnemonic("  mnemonic-primary  ");
+    settings.setCurrency("aud");
+
+    expect(settings.getSettings()).toEqual({
+      "default-mnemonic": "mnemonic-primary",
+      currency: "AUD",
+    });
+
+    const persisted = JSON.parse(readFileSync(settingsPath, "utf8")) as {
+      "default-mnemonic"?: string;
+      currency: string;
+    };
+    expect(persisted).toEqual({
+      "default-mnemonic": "mnemonic-primary",
+      currency: "AUD",
+    });
+  });
+
+  test("emits settings-updated events on setting changes", () => {
+    const settings = new SettingsService(settingsPath);
+    const events: Array<{ key: string; value: string | undefined }> = [];
+
+    settings.on("settings-updated", (event) => {
+      events.push({ key: event.key, value: event.value });
+    });
+
+    settings.setCurrency("cad");
+    settings.setDefaultMnemonic("mnemonic-blue");
+
+    expect(events).toEqual([
+      { key: "currency", value: "CAD" },
+      { key: "default-mnemonic", value: "mnemonic-blue" },
+    ]);
+  });
+});
Author	SHA1	Message	Date
Harvey Zuccon	b2ccff5b19	Add random mnemonic generation in seed input screen	2026-05-19 13:31:01 +02:00
Harvmaster	b4d82b8b1f	Before bliss	2026-05-16 05:59:55 +00:00
Harvmaster	a0d9775015	Add variable step	2026-05-11 12:18:47 +00:00
Harvmaster	6c01ac1c1b	Add currency settings, Settings service, and dialog to select fiat currency. Add support for non Official currencies like DOGE when using rates.	2026-05-11 10:41:41 +00:00
Harvmaster	ebe1d8acda	Add copy to generate address	2026-05-11 02:52:52 +00:00
Harvmaster	c2334b2cdd	Document that storage should be removed once engine can provide invitation data. Also documented memory adapter should be moved as its only used in the tests	2026-05-04 12:15:39 +00:00
Harvmaster	dec228063b	Remove the Logger. Was used temporarily as a remote logger for debugging	2026-05-04 12:15:06 +00:00
Harvmaster	3c47ee8a4c	Add documentation to the commands for the CLI	2026-05-04 12:14:40 +00:00
Harvmaster	8d7856f32e	Remove scripts	2026-05-04 12:14:15 +00:00
Harvmaster	b8b0a4a1ba	Improve output resolution in invitation screen	2026-05-04 11:45:52 +00:00
Harvmaster	dedfb69dff	Fix history for the 100th time. Fix role resolution in the invitation screen	2026-05-04 11:36:09 +00:00
Harvmaster	2f2e515d72	Fix change output and default locking script function	2026-05-04 10:00:49 +00:00
Harvmaster	7ffb5c44b5	Fix history. Fix invitation accept	2026-05-04 09:28:23 +00:00
Harvmaster	f978d740fe	Add autocomplete installation scripts to package.json. Update readme.	2026-05-04 05:09:40 +00:00
Harvmaster	6196d33b2a	Fix build issues	2026-05-04 05:04:28 +00:00
Harvmaster	ccfaf3fd70	Update to use published packages. Update types. Update readme. Fix tests.	2026-05-04 04:45:31 +00:00
Harvmaster	531e53d2ae	Fix test	2026-04-27 12:47:02 +00:00
Harvmaster	b708c8c1f8	Fix invitation import reactivity and focus imported invitation	2026-04-27 12:46:52 +00:00
Harvmaster	53ad7b729e	Fix clipboard actions over ssh	2026-04-27 12:45:04 +00:00
Harvmaster	e73fb24422	Add installation instruction as readme	2026-04-27 12:35:54 +00:00
Harvmaster	b282bbf5d6	Update readme for cli and command parsing	2026-04-27 09:48:10 +00:00
Harvmaster	bd1ae909b5	Fix tests	2026-04-27 09:45:38 +00:00
Harvmaster	e97054fa34	Fix help docs	2026-04-27 09:45:07 +00:00
Harvmaster	a43a45831c	Missed the utils file during previous commit	2026-04-27 09:44:42 +00:00
Harvmaster	1bbc21c742	Remove [next] from template actions	2026-04-27 09:14:44 +00:00
Harvmaster	9fa87d01b3	Combine cli-utils with utils	2026-04-27 09:14:30 +00:00
Harvmaster	7ad17a7c0e	Add oracle rates	2026-04-27 08:42:51 +00:00
Harvmaster	dbfb2c68d2	Formatting	2026-04-20 12:26:35 +00:00