@sundaeswap/sprinkles 0.1.1

package/src/Sprinkle/index.ts

@@ -0,0 +1,1215 @@
+import { Blockfrost, type Provider } from "@blaze-cardano/query";
+import {
+  Blaze,
+  ColdWallet,
+  Core,
+  HotWallet,
+  type Wallet,
+} from "@blaze-cardano/sdk";
+import { CborSet, VkeyWitness } from "@blaze-cardano/core";
+import { confirm, input, password, search, select } from "@inquirer/prompts";
+import {
+  Kind,
+  type Static,
+  type TBigInt,
+  type TLiteral,
+  type TObject,
+  type TSchema,
+  type TString,
+  type TUnion,
+  Type,
+  type TArray,
+  type TThis,
+  type TRef,
+  type TImport,
+  type TOptional,
+  OptionalKind,
+} from "@sinclair/typebox";
+import * as fs from "fs";
+import * as path from "path";
+export * from "@sinclair/typebox";
+
+export type TExact<T> = T extends TSchema ? Static<T> : T;
+
+const isOptional = <T extends TSchema>(t: T): t is TOptional<T> =>
+  t[OptionalKind] === "Optional";
+const isImport = (t: TSchema): t is TImport => t[Kind] === "Import";
+const isArray = (t: TSchema): t is TArray => t[Kind] === "Array";
+const isBigInt = (t: TSchema): t is TBigInt => t[Kind] === "BigInt";
+// const isBoolean = (t: TSchema): t is TBoolean => t[Kind] === "Boolean";
+const isLiteral = (t: TSchema): t is TLiteral => t[Kind] === "Literal";
+// const isNumber = (t: TSchema): t is TNumber => t[Kind] === "Number";
+const isObject = (t: TSchema): t is TObject => t[Kind] === "Object";
+// const isRecord = (t: TSchema): t is TRecord => t[Kind] === "Record";
+const isRef = (t: TSchema): t is TRef => t[Kind] === "Ref";
+const isString = (t: TSchema): t is TString => t[Kind] === "String";
+const isThis = (t: TSchema): t is TThis => t[Kind] === "This";
+// const isTuple = (t: TSchema): t is TTuple => t[Kind] === "Tuple";
+const isUnion = (t: TSchema): t is TUnion => t[Kind] === "Union";
+// const isAny = (t: TSchema): t is TAny => t[Kind] === "Any";
+
+const isSensitive = (t: TSchema): boolean =>
+  isString(t) && t.sensitive === true;
+
+export interface IEncryptionOptions {
+  encrypt: (plaintext: string) => string;
+  decrypt: (ciphertext: string) => Promise<string>;
+}
+
+export interface ISprinkleOptions {
+  encryption?: IEncryptionOptions;
+}
+
+export interface IProfileMeta {
+  name: string;
+  description?: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface IProfileEntry {
+  id: string;
+  meta: IProfileMeta;
+}
+
+export const NetworkSchema = Type.Union([
+  Type.Literal("mainnet"),
+  Type.Literal("preview"),
+  Type.Literal("preprod"),
+]);
+
+export const MultisigScriptModule = Type.Module({
+  MultisigScript: Type.Union([
+    Type.Object({
+      Signature: Type.Object(
+        {
+          key_hash: Type.String(),
+        },
+        { ctor: 0n },
+      ),
+    }),
+    Type.Object({
+      AllOf: Type.Object(
+        {
+          scripts: Type.Array(Type.Ref("MultisigScript")),
+        },
+        { ctor: 1n },
+      ),
+    }),
+    Type.Object({
+      AnyOf: Type.Object(
+        {
+          scripts: Type.Array(Type.Ref("MultisigScript")),
+        },
+        { ctor: 2n },
+      ),
+    }),
+    Type.Object({
+      AtLeast: Type.Object(
+        {
+          required: Type.BigInt(),
+          scripts: Type.Array(Type.Ref("MultisigScript")),
+        },
+        { ctor: 3n },
+      ),
+    }),
+    Type.Object({
+      Before: Type.Object(
+        {
+          time: Type.BigInt(),
+        },
+        { ctor: 4n },
+      ),
+    }),
+    Type.Object({
+      After: Type.Object(
+        {
+          time: Type.BigInt(),
+        },
+        { ctor: 5n },
+      ),
+    }),
+    Type.Object({
+      Script: Type.Object(
+        {
+          script_hash: Type.String(),
+        },
+        { ctor: 6n },
+      ),
+    }),
+  ]),
+});
+export const MultisigScript = MultisigScriptModule.Import("MultisigScript");
+export type TMultisigScript = TExact<typeof MultisigScript>;
+
+export const ProviderSettingsSchema = Type.Union([
+  Type.Object({
+    type: Type.Literal("blockfrost"),
+    projectId: Type.String({ minLength: 1, title: "Blockfrost Project ID" }),
+  }),
+  Type.Object({
+    type: Type.Literal("maestro"),
+    apiKey: Type.String({ minLength: 1, title: "Maestro API Key" }),
+  }),
+]);
+
+export const WalletSettingsSchema = Type.Union([
+  Type.Object({
+    type: Type.Literal("hot"),
+    privateKey: Type.String({ minLength: 1, title: "Hot Wallet Private Key" }),
+  }),
+  Type.Object({
+    type: Type.Literal("cold"),
+    address: Type.String({ minLength: 1, title: "Cold Wallet Address" }),
+  }),
+]);
+
+export interface IMenuAction<S extends TSchema> {
+  title: string;
+  action: (sprinkle: Sprinkle<S>) => Promise<Sprinkle<S> | void>;
+}
+export type TMenuItem<S extends TSchema> = IMenuAction<S> | IMenu<S>;
+export interface IMenu<S extends TSchema> {
+  title: string;
+  items: TMenuItem<S>[];
+  beforeShow?: (sprinkle: Sprinkle<S>) => Promise<void>;
+}
+
+export class Sprinkle<S extends TSchema> {
+  storagePath: string;
+  settings: TExact<S> = {} as TExact<S>;
+  type: S;
+  defaults: Record<string, unknown> = {};
+  options: ISprinkleOptions;
+  profileId: string = "";
+  profileMeta: IProfileMeta = { name: "", createdAt: "", updatedAt: "" };
+
+  constructor(type: S, storagePath: string, options?: ISprinkleOptions) {
+    this.type = type;
+    this.storagePath = storagePath;
+    this.options = options ?? {};
+  }
+
+  // --- Profile path helpers ---
+
+  static sanitizeProfileId(name: string): string {
+    return (
+      name
+        .toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, "")
+        .replace(/[\s]+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "") || "profile"
+    );
+  }
+
+  private static profilesDir(storagePath: string): string {
+    return path.join(storagePath, "profiles");
+  }
+
+  private static profilePath(storagePath: string, id: string): string {
+    if (!id || /[\/\\]/.test(id) || id.includes("..")) {
+      throw new Error(`Invalid profile ID: "${id}"`);
+    }
+    return path.join(storagePath, "profiles", `${id}.json`);
+  }
+
+  private static activeProfilePath(storagePath: string): string {
+    return path.join(storagePath, "active-profile");
+  }
+
+  private static findAvailableId(profilesDir: string, baseId: string): string {
+    let candidate = baseId;
+    let counter = 2;
+    while (fs.existsSync(path.join(profilesDir, `${candidate}.json`))) {
+      candidate = `${baseId}-${counter}`;
+      counter++;
+    }
+    return candidate;
+  }
+
+  // --- Profile I/O ---
+
+  scanProfiles(): IProfileEntry[] {
+    const dir = Sprinkle.profilesDir(this.storagePath);
+    if (!fs.existsSync(dir)) return [];
+    const files = fs.readdirSync(dir).filter((f) => f.endsWith(".json"));
+    const entries: IProfileEntry[] = [];
+    for (const file of files) {
+      try {
+        const content = fs.readFileSync(path.join(dir, file), "utf-8");
+        const parsed = JSON.parse(content, Sprinkle.bigIntReviver);
+        if (parsed.meta?.name) {
+          entries.push({
+            id: file.replace(/\.json$/, ""),
+            meta: parsed.meta,
+          });
+        }
+      } catch {
+        // Skip malformed profile files
+      }
+    }
+    return entries;
+  }
+
+  async loadProfile(id: string): Promise<void> {
+    const filePath = Sprinkle.profilePath(this.storagePath, id);
+    const content = fs.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(content, Sprinkle.bigIntReviver);
+    this.profileId = id;
+    this.profileMeta = parsed.meta;
+    this.settings = await this.decryptSettings(parsed.settings as TExact<S>);
+    this.defaults = parsed.defaults ?? {};
+    // Update active profile pointer
+    fs.writeFileSync(Sprinkle.activeProfilePath(this.storagePath), id, "utf-8");
+  }
+
+  private saveProfile(): void {
+    if (!this.profileId) {
+      throw new Error(
+        "Cannot save profile: no profile is loaded. Call loadProfile() or create a profile first.",
+      );
+    }
+    const filePath = Sprinkle.profilePath(this.storagePath, this.profileId);
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    this.profileMeta.updatedAt = new Date().toISOString();
+    const settingsToSave = this.encryptSettings(this.settings);
+    const jsonContent = JSON.stringify(
+      {
+        meta: this.profileMeta,
+        settings: settingsToSave,
+        defaults: this.defaults,
+      },
+      Sprinkle.bigIntReplacer,
+      2,
+    );
+    fs.writeFileSync(filePath, jsonContent, "utf-8");
+  }
+
+  private async promptProfileMeta(
+    defaultName?: string,
+    defaultDescription?: string,
+  ): Promise<{ name: string; description?: string }> {
+    const name = await input({
+      message: "Profile name:",
+      default: defaultName,
+      validate: (v) => (v.trim().length > 0 ? true : "Name cannot be empty"),
+    });
+    const description = await input({
+      message: "Profile description (optional):",
+      default: defaultDescription ?? "",
+    });
+    return { name, description: description || undefined };
+  }
+
+  private async createProfile(): Promise<void> {
+    const { name, description } = await this.promptProfileMeta();
+    const profilesDir = Sprinkle.profilesDir(this.storagePath);
+    const id = Sprinkle.findAvailableId(
+      profilesDir,
+      Sprinkle.sanitizeProfileId(name),
+    );
+    const now = new Date().toISOString();
+    this.profileId = id;
+    this.profileMeta = { name, description, createdAt: now, updatedAt: now };
+    this.defaults = {};
+    this.settings = await this.FillInStruct(this.type);
+    this.saveProfile();
+    fs.writeFileSync(Sprinkle.activeProfilePath(this.storagePath), id, "utf-8");
+  }
+
+  private async migrateIfNeeded(): Promise<void> {
+    const profilesDir = Sprinkle.profilesDir(this.storagePath);
+    const legacyPath = Sprinkle.SettingsPath(this.storagePath);
+
+    if (!fs.existsSync(profilesDir)) {
+      if (fs.existsSync(legacyPath)) {
+        // Migrate legacy settings.json -> profiles/default.json
+        const content = fs.readFileSync(legacyPath, "utf-8");
+        const parsed = JSON.parse(content, Sprinkle.bigIntReviver);
+        const now = new Date().toISOString();
+        const profileData = {
+          meta: {
+            name: "Default",
+            createdAt: now,
+            updatedAt: now,
+          },
+          settings: parsed.settings,
+          defaults: parsed.defaults ?? {},
+        };
+        fs.mkdirSync(profilesDir, { recursive: true });
+        fs.writeFileSync(
+          Sprinkle.profilePath(this.storagePath, "default"),
+          JSON.stringify(profileData, Sprinkle.bigIntReplacer, 2),
+          "utf-8",
+        );
+        fs.writeFileSync(
+          Sprinkle.activeProfilePath(this.storagePath),
+          "default",
+          "utf-8",
+        );
+        // Backup legacy file
+        fs.renameSync(legacyPath, `${legacyPath}.bak`);
+      } else {
+        fs.mkdirSync(profilesDir, { recursive: true });
+      }
+    }
+  }
+
+  private async selectOrCreateProfile(): Promise<void> {
+    const profiles = this.scanProfiles();
+
+    if (profiles.length === 0) {
+      await this.createProfile();
+      return;
+    }
+
+    if (profiles.length === 1) {
+      await this.loadProfile(profiles[0]!.id);
+      return;
+    }
+
+    // Multiple profiles: check active-profile pointer
+    const pointerPath = Sprinkle.activeProfilePath(this.storagePath);
+    if (fs.existsSync(pointerPath)) {
+      const activeId = fs.readFileSync(pointerPath, "utf-8").trim();
+      if (profiles.some((p) => p.id === activeId)) {
+        await this.loadProfile(activeId);
+        return;
+      }
+    }
+
+    // No valid pointer - show selector
+    await this.selectProfile(profiles);
+  }
+
+  private async selectProfile(profiles?: IProfileEntry[]): Promise<void> {
+    const available = profiles ?? this.scanProfiles();
+    const selection = await select({
+      message: "Select a profile:",
+      choices: available.map((p) => ({
+        name: p.meta.description
+          ? `${p.meta.name} - ${p.meta.description}`
+          : p.meta.name,
+        value: p.id,
+      })),
+    });
+    await this.loadProfile(selection);
+  }
+
+  // --- Profile management (CRUD) ---
+
+  private async duplicateProfile(): Promise<void> {
+    const { name, description } = await this.promptProfileMeta(
+      `${this.profileMeta.name} (copy)`,
+      this.profileMeta.description,
+    );
+    const profilesDir = Sprinkle.profilesDir(this.storagePath);
+    const id = Sprinkle.findAvailableId(
+      profilesDir,
+      Sprinkle.sanitizeProfileId(name),
+    );
+    const now = new Date().toISOString();
+    // Write duplicate with current settings
+    const settingsToSave = this.encryptSettings(this.settings);
+    const jsonContent = JSON.stringify(
+      {
+        meta: { name, description, createdAt: now, updatedAt: now },
+        settings: settingsToSave,
+        defaults: this.defaults,
+      },
+      Sprinkle.bigIntReplacer,
+      2,
+    );
+    fs.writeFileSync(
+      path.join(profilesDir, `${id}.json`),
+      jsonContent,
+      "utf-8",
+    );
+    console.log(`Profile "${name}" created as a copy.`);
+  }
+
+  private async renameProfile(): Promise<void> {
+    const { name, description } = await this.promptProfileMeta(
+      this.profileMeta.name,
+      this.profileMeta.description,
+    );
+    const newId = Sprinkle.sanitizeProfileId(name);
+    const oldId = this.profileId;
+
+    this.profileMeta.name = name;
+    this.profileMeta.description = description;
+
+    if (newId !== oldId) {
+      const newPath = Sprinkle.profilePath(this.storagePath, newId);
+      if (fs.existsSync(newPath)) {
+        console.log(
+          `A profile with ID "${newId}" already exists. Choose a different name.`,
+        );
+        return;
+      }
+      // Save to new path, remove old file
+      this.profileId = newId;
+      this.saveProfile();
+      fs.unlinkSync(Sprinkle.profilePath(this.storagePath, oldId));
+      fs.writeFileSync(
+        Sprinkle.activeProfilePath(this.storagePath),
+        newId,
+        "utf-8",
+      );
+    } else {
+      this.saveProfile();
+    }
+    console.log(`Profile renamed to "${name}".`);
+  }
+
+  private async deleteProfile(): Promise<void> {
+    const profiles = this.scanProfiles();
+    const others = profiles.filter((p) => p.id !== this.profileId);
+
+    if (others.length === 0) {
+      console.log("Cannot delete the only profile.");
+      return;
+    }
+
+    const toDelete = await select({
+      message: "Select a profile to delete:",
+      choices: [
+        ...others.map((p) => ({
+          name: p.meta.description
+            ? `${p.meta.name} - ${p.meta.description}`
+            : p.meta.name,
+          value: p.id,
+        })),
+        { name: "Cancel", value: "__cancel__" },
+      ],
+    });
+
+    if (toDelete === "__cancel__") return;
+
+    const profileToDelete = others.find((p) => p.id === toDelete);
+    const confirmed = await confirm({
+      message: `Delete profile "${profileToDelete?.meta.name ?? toDelete}"? This cannot be undone.`,
+      default: false,
+    });
+
+    if (confirmed) {
+      fs.unlinkSync(Sprinkle.profilePath(this.storagePath, toDelete));
+      console.log(
+        `Profile "${profileToDelete?.meta.name ?? toDelete}" deleted.`,
+      );
+    }
+  }
+
+  // --- Menu ---
+
+  async showMenu(menu: IMenu<S>): Promise<void> {
+    return this._showMenu(menu, true);
+  }
+
+  private async _showMenu(menu: IMenu<S>, main: boolean): Promise<void> {
+    if (menu.beforeShow) {
+      await menu.beforeShow(this);
+    }
+    const choices = menu.items.map((item, index) => {
+      if ("action" in item) {
+        return { name: item.title, value: index };
+      } else {
+        return { name: `${item.title} Submenu`, value: index };
+      }
+    });
+    if (!main) {
+      choices.push({ name: "Back", value: -1 });
+    } else {
+      choices.push({ name: "Settings & Profiles", value: -5 });
+      choices.push({ name: "Exit", value: -1 });
+    }
+    const selection = await select({
+      message: "Select an option:",
+      choices: choices,
+    });
+    if (selection === -5) {
+      const settingsMenu: IMenu<S> = {
+        title: "Settings & Profiles",
+        items: [
+          {
+            title: "Edit settings",
+            action: async () => {
+              this.settings = await this.EditStruct(this.type, this.settings);
+              this.saveSettings();
+            },
+          },
+          {
+            title: "Switch profile",
+            action: async () => {
+              this.saveSettings();
+              const profiles = this.scanProfiles();
+              if (profiles.length <= 1) {
+                console.log(
+                  "No other profiles to switch to. Create a new one first.",
+                );
+              } else {
+                await this.selectProfile(profiles);
+              }
+            },
+          },
+          {
+            title: "Create new profile",
+            action: async () => {
+              await this.createProfile();
+            },
+          },
+          {
+            title: "Duplicate current profile",
+            action: async () => {
+              await this.duplicateProfile();
+            },
+          },
+          {
+            title: "Rename current profile",
+            action: async () => {
+              await this.renameProfile();
+            },
+          },
+          {
+            title: "Delete a profile",
+            action: async () => {
+              await this.deleteProfile();
+            },
+          },
+        ],
+      };
+      await this._showMenu(settingsMenu, false);
+      await this._showMenu(menu, main);
+      return;
+    }
+    if (selection === -1) {
+      return;
+    }
+    const selectedItem = menu.items[selection]!;
+    if ("action" in selectedItem) {
+      const result = await selectedItem.action(this);
+      if (result instanceof Sprinkle) {
+        this.settings = result.settings;
+        this.saveSettings();
+      }
+      await this._showMenu(menu, main);
+    } else {
+      await this._showMenu(selectedItem, false);
+      await this._showMenu(menu, main);
+    }
+    return;
+  }
+
+  static async New<S extends TSchema>(
+    type: S,
+    storagePath: string,
+    options?: ISprinkleOptions,
+  ): Promise<Sprinkle<S>> {
+    const sprinkle = new Sprinkle<S>(type, storagePath, options);
+    await sprinkle.migrateIfNeeded();
+    await sprinkle.selectOrCreateProfile();
+    sprinkle.saveSettings();
+    return sprinkle;
+  }
+
+  static async GetProvider(
+    network: TExact<typeof NetworkSchema>,
+    settings: TExact<typeof ProviderSettingsSchema>,
+  ): Promise<Provider> {
+    switch (settings.type) {
+      case "blockfrost":
+        return new Blockfrost({
+          network: `cardano-${network}`,
+          projectId: settings.projectId,
+        });
+      case "maestro":
+        // Dynamic import - Maestro may or may not be exported depending on @blaze-cardano/query version
+        const queryModule = (await import("@blaze-cardano/query")) as any;
+        if (!queryModule.Maestro) {
+          throw new Error(
+            "Maestro is not available in the installed version of @blaze-cardano/query. Please install a version that includes Maestro support.",
+          );
+        }
+        return new queryModule.Maestro({
+          network: network as "mainnet" | "preview" | "preprod",
+          apiKey: settings.apiKey,
+        });
+      default:
+        throw new Error("Invalid provider type");
+    }
+  }
+
+  static async GetWallet(
+    settings: TExact<typeof WalletSettingsSchema>,
+    provider: Provider,
+  ): Promise<Wallet> {
+    switch (settings.type) {
+      case "hot":
+        return HotWallet.fromMasterkey(
+          Core.Bip32PrivateKeyHex(settings.privateKey),
+          provider,
+          provider.network,
+        );
+      case "cold":
+        return new ColdWallet(
+          Core.Address.fromBech32(settings.address),
+          provider.network,
+          provider,
+        );
+      default:
+        throw new Error("Invalid wallet type");
+    }
+  }
+
+  static async GetBlaze(
+    network: TExact<typeof NetworkSchema>,
+    providerSettings: TExact<typeof ProviderSettingsSchema>,
+    walletSettings: TExact<typeof WalletSettingsSchema>,
+  ): Promise<Blaze<Provider, Wallet>> {
+    const provider = await Sprinkle.GetProvider(network, providerSettings);
+    const wallet = await Sprinkle.GetWallet(walletSettings, provider);
+    return Blaze.from(provider, wallet);
+  }
+
+  static async SearchSelect<T>(opts: {
+    message: string;
+    source: (
+      term: string | undefined,
+    ) => Promise<{ name: string; value: T }[]> | { name: string; value: T }[];
+  }): Promise<T> {
+    return search(opts) as Promise<T>;
+  }
+
+  static SettingsPath(storagePath: string): string {
+    return `${storagePath}${path.sep}settings.json`;
+  }
+
+  async LoadSettings(type: S, storagePath: string): Promise<void> {
+    try {
+      // Check if the settings file exists
+      if (fs.existsSync(storagePath)) {
+        // Read and parse the JSON file
+        const fileContent = fs.readFileSync(storagePath, "utf-8");
+        const parsed = JSON.parse(fileContent, Sprinkle.bigIntReviver) as {
+          settings: unknown;
+          defaults: Record<string, unknown>;
+        };
+        // Convert string representations back to BigInt where needed
+        this.settings = await this.decryptSettings(
+          parsed.settings as TExact<S>,
+        );
+        this.defaults = parsed.defaults;
+      } else {
+        this.defaults = {};
+        this.settings = await this.FillInStruct(type);
+      }
+    } catch (error) {
+      throw new Error(`Error loading settings from ${storagePath}: ${error}`);
+    }
+  }
+
+  static bigIntReviver(key: string, value: unknown): unknown {
+    if (typeof value === "string" && /^\d+n$/.test(value)) {
+      return BigInt(value.slice(0, -1));
+    }
+    return value;
+  }
+
+  private static bigIntReplacer(_key: string, value: unknown): unknown {
+    return typeof value === "bigint" ? `${value.toString()}n` : value;
+  }
+
+  private static collectSensitivePaths(
+    type: TSchema,
+    prefix: string = "",
+  ): string[] {
+    const paths: string[] = [];
+    if (isObject(type)) {
+      const fields = type["properties"] as Record<string, TSchema>;
+      for (const [field, fieldType] of Object.entries(fields)) {
+        const fieldPath = prefix ? `${prefix}.${field}` : field;
+        if (isSensitive(fieldType)) {
+          paths.push(fieldPath);
+        }
+        paths.push(...Sprinkle.collectSensitivePaths(fieldType, fieldPath));
+      }
+    }
+    if (isUnion(type)) {
+      for (const variant of type.anyOf) {
+        paths.push(...Sprinkle.collectSensitivePaths(variant, prefix));
+      }
+    }
+    return paths;
+  }
+
+  private static getNestedValue(obj: any, path: string): unknown {
+    return path.split(".").reduce((o, k) => o?.[k], obj);
+  }
+
+  private static setNestedValue(obj: any, path: string, value: unknown): void {
+    const keys = path.split(".");
+    const last = keys.pop()!;
+    const parent = keys.reduce((o, k) => o?.[k], obj);
+    if (parent && typeof parent === "object") {
+      parent[last] = value;
+    }
+  }
+
+  private encryptSettings(settings: TExact<S>): TExact<S> {
+    if (!this.options.encryption) return settings;
+    const clone = JSON.parse(
+      JSON.stringify(settings, Sprinkle.bigIntReplacer),
+      Sprinkle.bigIntReviver,
+    );
+    const sensitivePaths = Sprinkle.collectSensitivePaths(this.type);
+    for (const p of sensitivePaths) {
+      const value = Sprinkle.getNestedValue(clone, p);
+      if (typeof value === "string" && value.length > 0) {
+        Sprinkle.setNestedValue(
+          clone,
+          p,
+          this.options.encryption.encrypt(value),
+        );
+      }
+    }
+    return clone;
+  }
+
+  private async decryptSettings(settings: TExact<S>): Promise<TExact<S>> {
+    if (!this.options.encryption) return settings;
+    const clone = JSON.parse(
+      JSON.stringify(settings, Sprinkle.bigIntReplacer),
+      Sprinkle.bigIntReviver,
+    );
+    const sensitivePaths = Sprinkle.collectSensitivePaths(this.type);
+    for (const p of sensitivePaths) {
+      const value = Sprinkle.getNestedValue(clone, p);
+      if (typeof value === "string" && value.length > 0) {
+        Sprinkle.setNestedValue(
+          clone,
+          p,
+          await this.options.encryption.decrypt(value),
+        );
+      }
+    }
+    return clone;
+  }
+
+  saveSettings(): void {
+    this.saveProfile();
+  }
+
+  async TxDialog<P extends Provider, W extends Wallet>(
+    blaze: Blaze<P, W>,
+    tx: Core.Transaction,
+    opts?: { beforeSign?: () => Promise<void> },
+  ): Promise<void> {
+    const txCbor = tx.toCbor();
+    let expanded = false;
+
+    const showDialog = async (): Promise<void> => {
+      if (expanded) {
+        console.log("Transaction CBOR:", txCbor);
+      } else {
+        console.log("Transaction CBOR:", `${String(txCbor).slice(0, 50)}...`);
+      }
+
+      const menuItems: TMenuItem<S>[] = [];
+
+      if (!expanded) {
+        menuItems.push({
+          title: "Expand CBOR",
+          action: async () => {
+            expanded = true;
+            await showDialog();
+          },
+        });
+      }
+
+      menuItems.push({
+        title: "Copy CBOR to clipboard",
+        action: async () => {
+          try {
+            const { default: clipboard } = await import("clipboardy");
+            clipboard.writeSync(String(txCbor));
+            console.log("Transaction CBOR copied to clipboard.");
+          } catch (e) {
+            console.log("Failed to copy to clipboard, expanding instead.");
+            expanded = true;
+            await showDialog();
+          }
+        },
+      });
+
+      if (blaze.wallet instanceof HotWallet) {
+        menuItems.push({
+          title: "Sign and submit transaction",
+          action: async () => {
+            if (opts?.beforeSign) {
+              await opts.beforeSign();
+            }
+
+            // Detect if stake key signature is required
+            let needsStakeKey = false;
+            try {
+              const wallet = blaze.wallet as unknown as HotWallet;
+              const addresses = await wallet.getUsedAddresses();
+              const userAddress = addresses[0];
+              if (userAddress) {
+                const stakeCredential = userAddress
+                  .asBase()
+                  ?.getStakeCredential();
+                const stakeKeyHash = stakeCredential?.hash?.toString();
+
+                if (stakeKeyHash) {
+                  const requiredSigners = tx.body().requiredSigners();
+                  if (requiredSigners) {
+                    const signerArray = Array.from(requiredSigners.values());
+                    needsStakeKey = signerArray.some(
+                      (signer) => signer.toString() === stakeKeyHash,
+                    );
+                  }
+
+                  const certs = tx.body().certs();
+                  const hasCertificates = certs && certs.size() > 0;
+                  const withdrawals = tx.body().withdrawals();
+                  const hasWithdrawals = withdrawals && withdrawals.size > 0;
+
+                  if (hasCertificates || hasWithdrawals) {
+                    needsStakeKey = true;
+                  }
+                }
+              }
+
+              if (needsStakeKey) {
+                console.log("Transaction requires stake key signature.");
+              } else {
+                console.log("Transaction requires payment key signature only.");
+              }
+            } catch (error) {
+              console.warn(
+                "Could not determine stake key requirement, signing with payment key only.",
+              );
+              console.warn(`Error: ${(error as Error).message}`);
+            }
+
+            let signedTx;
+
+            if (needsStakeKey) {
+              const signed = await (
+                blaze.wallet as unknown as HotWallet
+              ).signTransaction(tx, true, true);
+              const ws = tx.witnessSet();
+              const vkeys = ws.vkeys()?.toCore() ?? [];
+
+              const signedKeys = signed.vkeys();
+              if (!signedKeys) {
+                throw new Error(
+                  "signTransaction: no signed keys in wallet witness response",
+                );
+              }
+
+              if (
+                signedKeys
+                  .toCore()
+                  .some(([vkey]) => vkeys.some(([key2]) => vkey === key2))
+              ) {
+                throw new Error(
+                  "signTransaction: some keys were already signed",
+                );
+              }
+
+              ws.setVkeys(
+                CborSet.fromCore(
+                  [...signedKeys.toCore(), ...vkeys],
+                  VkeyWitness.fromCore,
+                ),
+              );
+              tx.setWitnessSet(ws);
+              signedTx = tx;
+            } else {
+              signedTx = await blaze.signTransaction(tx);
+            }
+
+            const txId = await blaze.submitTransaction(signedTx);
+            console.log(`Transaction submitted: ${txId}`);
+          },
+        });
+      }
+
+      const txMenu: IMenu<S> = {
+        title: "Transaction Menu",
+        items: menuItems,
+      };
+      await this._showMenu(txMenu, false);
+    };
+
+    await showDialog();
+  }
+
+  async EditStruct<U extends TSchema>(
+    type: U,
+    current: TExact<U>,
+  ): Promise<TExact<U>> {
+    return this._editStruct<U>(type, ["root"], current);
+  }
+
+  async _editStruct<U extends TSchema>(
+    type: U,
+    path: string[],
+    current?: TExact<U>,
+  ): Promise<TExact<U>> {
+    if (isObject(type)) {
+      const obj = {} as Record<string, unknown>;
+      const fields = type["properties"] as Record<string, U>;
+      const menuItems: TMenuItem<S>[] = [];
+      const currentRecord = current as Record<string, unknown>;
+      for (const [field, fieldType] of Object.entries(fields)) {
+        if (current && field in currentRecord) {
+          obj[field] = currentRecord[field] as TExact<U>;
+        }
+        const menuTitle = Sprinkle.ExtractMessage(
+          fieldType,
+          `Edit ${field} at ${path.join(".")}`,
+        );
+        if (
+          isOptional(fieldType) &&
+          current &&
+          currentRecord[field] !== undefined
+        ) {
+          menuItems.push({
+            title: `Clear ${field}`,
+            action: async (sprinkle: Sprinkle<S>) => {
+              obj[field] = undefined;
+              return sprinkle;
+            },
+          });
+        }
+        menuItems.push({
+          title: menuTitle,
+          action: async (sprinkle: Sprinkle<S>) => {
+            const fieldValue = await sprinkle._editStruct(
+              fieldType,
+              path.concat([field]),
+              current && field in currentRecord
+                ? (currentRecord[field] as TExact<U>)
+                : undefined,
+            );
+            obj[field] = fieldValue;
+            return sprinkle;
+          },
+        });
+      }
+      const editMenu: IMenu<S> = {
+        title: "Test",
+        items: menuItems,
+      };
+      await this._showMenu(editMenu, false);
+      return obj as TExact<U>;
+    }
+
+    return this._fillInStruct<U>(type, path, {}, current);
+  }
+
+  async FillInStruct<U extends TSchema>(
+    type: U,
+    def?: TExact<U>,
+  ): Promise<TExact<U>> {
+    return this._fillInStruct<U>(type, ["root"], {}, def);
+  }
+
+  async _fillInStruct<U extends TSchema>(
+    type: U,
+    path: string[],
+    defs: Record<string, TSchema>,
+    def?: TExact<U>,
+  ): Promise<TExact<U>> {
+    if ("$ref" in type) {
+      defs = { ...defs, ...type["$defs"] };
+      const resolvedType = defs[type["$ref"]];
+      if (!resolvedType) {
+        throw new Error(
+          `Could not resolve type ${type["$ref"]} at ${path.join(".")}`,
+        );
+      }
+      return this._fillInStruct(resolvedType, path, defs, def) as Promise<
+        TExact<U>
+      >;
+    }
+    if (isOptional(type)) {
+      const shouldSet = await select({
+        message: Sprinkle.ExtractMessage(
+          type,
+          `Set value for ${path.join(".")}?`,
+        ),
+        choices: [
+          { name: "Yes", value: true },
+          { name: "Skip", value: false },
+        ],
+        default: def !== undefined,
+      });
+      if (!shouldSet) {
+        return undefined as TExact<U>;
+      }
+      // Unwrap the optional and fill the inner type
+      const innerType = { ...type };
+      delete (innerType as any)[OptionalKind];
+      return this._fillInStruct(innerType as U, path, defs, def);
+    }
+
+    if (isUnion(type)) {
+      const choices = [];
+      const resolved = this.resolveType(type, path, defs);
+      for (const variant of resolved.anyOf) {
+        choices.push({
+          name: Sprinkle.ExtractMessage(variant, `${variant}`),
+          value: variant,
+        });
+      }
+      const selection = await select({
+        message: Sprinkle.ExtractMessage(
+          resolved,
+          `Enter a choice for ${path.join(".")}`,
+        ),
+        choices: choices,
+        default: def ? `${def}` : undefined,
+      });
+      return this._fillInStruct(selection, path, defs) as Promise<TExact<U>>;
+    }
+
+    if (isString(type)) {
+      const defaultString = (def ? def : this.defaults["string"]) as
+        | string
+        | undefined;
+      const message = Sprinkle.ExtractMessage(
+        type,
+        `Enter a string for ${path.join(".")}`,
+      );
+      let answer: string;
+      if (isSensitive(type)) {
+        answer = await password({ message });
+      } else {
+        answer = await input({ message, default: defaultString });
+        this.defaults["string"] = answer;
+      }
+      return answer as TExact<U>;
+    }
+
+    if (isBigInt(type)) {
+      const answer = await input({
+        message: Sprinkle.ExtractMessage(
+          type,
+          `Enter a bigint for ${path.join(".")}`,
+        ),
+        default: def ? (def as bigint).toString() : undefined,
+        validate: (s) => {
+          try {
+            BigInt(s);
+            return true;
+          } catch {
+            return "Please enter a valid bigint.";
+          }
+        },
+      });
+      return BigInt(answer) as TExact<U>;
+    }
+
+    if (isLiteral(type)) {
+      return type.const as TExact<U>;
+    }
+
+    if (isObject(type)) {
+      const obj = {} as Record<string, unknown>;
+      const fields = type["properties"] as Record<string, U>;
+      for (const [field, fieldType] of Object.entries(fields)) {
+        const fieldValue = await this._fillInStruct(
+          fieldType,
+          path.concat([field]),
+          defs,
+          def
+            ? ((def as Record<string, unknown>)[field] as TExact<U>)
+            : undefined,
+        );
+        obj[field] = fieldValue;
+      }
+      return obj as TExact<U>;
+    }
+
+    //TODO: support starting with default values for arrays and allow removal of items
+    if (isArray(type)) {
+      const arr: unknown[] = [];
+      const itemType = type.items as U;
+      let addMore = true;
+      while (addMore) {
+        const itemValue = await this._fillInStruct(
+          itemType,
+          path.concat([`[${arr.length}]`]),
+          defs,
+        );
+        arr.push(itemValue);
+        const continueAnswer = await select({
+          message: `Add another item to ${path.join(".")}?`,
+          choices: [
+            { name: "Yes", value: true },
+            { name: "No", value: false },
+          ],
+        });
+        addMore = continueAnswer;
+      }
+      return arr as TExact<U>;
+    }
+
+    throw new Error(
+      `Unable to fill in struct for type at path ${path.join(".")}`,
+    );
+  }
+
+  resolveType<T extends TSchema>(
+    type: T,
+    path: string[],
+    defs: Record<string, TSchema>,
+  ): T {
+    if (isRef(type) || isThis(type) || isImport(type)) {
+      defs = { ...defs, ...type.$defs };
+      const realType = defs[type.$ref];
+      if (!realType) {
+        throw new Error(
+          `Invalid type at ${path.join(".")}: Unrecognized reference ${type.$ref}`,
+        );
+      }
+      return this.resolveType(realType, path, defs) as T;
+    }
+    return type;
+  }
+
+  static ExtractMessage(type: TSchema, def: string): string {
+    if ("title" in type) {
+      return type.title!;
+    }
+
+    if ("description" in type) {
+      return type.description!;
+    }
+
+    if (isLiteral(type)) {
+      return `${type.const}`;
+    }
+
+    if (isObject(type)) {
+      const fields = type["properties"] as Record<string, TSchema>;
+      if ("type" in fields) {
+        return Sprinkle.ExtractMessage(fields["type"], def);
+      }
+      const fieldNames = Object.keys(fields);
+      if (fieldNames.length === 1) {
+        return fieldNames[0]!;
+      }
+    }
+
+    return def;
+  }
+}