@sundaeswap/sprinkles 0.1.1

package/dist/esm/Sprinkle/index.js

@@ -0,0 +1,928 @@
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { Blockfrost } from "@blaze-cardano/query";
+import { Blaze, ColdWallet, Core, HotWallet } from "@blaze-cardano/sdk";
+import { CborSet, VkeyWitness } from "@blaze-cardano/core";
+import { confirm, input, password, search, select } from "@inquirer/prompts";
+import { Kind, Type, OptionalKind } from "@sinclair/typebox";
+import * as fs from "fs";
+import * as path from "path";
+export * from "@sinclair/typebox";
+const isOptional = t => t[OptionalKind] === "Optional";
+const isImport = t => t[Kind] === "Import";
+const isArray = t => t[Kind] === "Array";
+const isBigInt = t => t[Kind] === "BigInt";
+// const isBoolean = (t: TSchema): t is TBoolean => t[Kind] === "Boolean";
+const isLiteral = t => t[Kind] === "Literal";
+// const isNumber = (t: TSchema): t is TNumber => t[Kind] === "Number";
+const isObject = t => t[Kind] === "Object";
+// const isRecord = (t: TSchema): t is TRecord => t[Kind] === "Record";
+const isRef = t => t[Kind] === "Ref";
+const isString = t => t[Kind] === "String";
+const isThis = t => t[Kind] === "This";
+// const isTuple = (t: TSchema): t is TTuple => t[Kind] === "Tuple";
+const isUnion = t => t[Kind] === "Union";
+// const isAny = (t: TSchema): t is TAny => t[Kind] === "Any";
+
+const isSensitive = t => isString(t) && t.sensitive === true;
+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 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 class Sprinkle {
+  constructor(type, storagePath, options) {
+    _defineProperty(this, "storagePath", void 0);
+    _defineProperty(this, "settings", {});
+    _defineProperty(this, "type", void 0);
+    _defineProperty(this, "defaults", {});
+    _defineProperty(this, "options", void 0);
+    _defineProperty(this, "profileId", "");
+    _defineProperty(this, "profileMeta", {
+      name: "",
+      createdAt: "",
+      updatedAt: ""
+    });
+    this.type = type;
+    this.storagePath = storagePath;
+    this.options = options ?? {};
+  }
+
+  // --- Profile path helpers ---
+
+  static sanitizeProfileId(name) {
+    return name.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/[\s]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "") || "profile";
+  }
+  static profilesDir(storagePath) {
+    return path.join(storagePath, "profiles");
+  }
+  static profilePath(storagePath, id) {
+    if (!id || /[\/\\]/.test(id) || id.includes("..")) {
+      throw new Error(`Invalid profile ID: "${id}"`);
+    }
+    return path.join(storagePath, "profiles", `${id}.json`);
+  }
+  static activeProfilePath(storagePath) {
+    return path.join(storagePath, "active-profile");
+  }
+  static findAvailableId(profilesDir, baseId) {
+    let candidate = baseId;
+    let counter = 2;
+    while (fs.existsSync(path.join(profilesDir, `${candidate}.json`))) {
+      candidate = `${baseId}-${counter}`;
+      counter++;
+    }
+    return candidate;
+  }
+
+  // --- Profile I/O ---
+
+  scanProfiles() {
+    const dir = Sprinkle.profilesDir(this.storagePath);
+    if (!fs.existsSync(dir)) return [];
+    const files = fs.readdirSync(dir).filter(f => f.endsWith(".json"));
+    const entries = [];
+    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) {
+    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);
+    this.defaults = parsed.defaults ?? {};
+    // Update active profile pointer
+    fs.writeFileSync(Sprinkle.activeProfilePath(this.storagePath), id, "utf-8");
+  }
+  saveProfile() {
+    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");
+  }
+  async promptProfileMeta(defaultName, defaultDescription) {
+    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
+    };
+  }
+  async createProfile() {
+    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");
+  }
+  async migrateIfNeeded() {
+    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
+        });
+      }
+    }
+  }
+  async selectOrCreateProfile() {
+    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);
+  }
+  async selectProfile(profiles) {
+    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) ---
+
+  async duplicateProfile() {
+    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.`);
+  }
+  async renameProfile() {
+    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}".`);
+  }
+  async deleteProfile() {
+    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) {
+    return this._showMenu(menu, true);
+  }
+  async _showMenu(menu, main) {
+    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 = {
+        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(type, storagePath, options) {
+    const sprinkle = new Sprinkle(type, storagePath, options);
+    await sprinkle.migrateIfNeeded();
+    await sprinkle.selectOrCreateProfile();
+    sprinkle.saveSettings();
+    return sprinkle;
+  }
+  static async GetProvider(network, settings) {
+    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");
+        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,
+          apiKey: settings.apiKey
+        });
+      default:
+        throw new Error("Invalid provider type");
+    }
+  }
+  static async GetWallet(settings, provider) {
+    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, providerSettings, walletSettings) {
+    const provider = await Sprinkle.GetProvider(network, providerSettings);
+    const wallet = await Sprinkle.GetWallet(walletSettings, provider);
+    return Blaze.from(provider, wallet);
+  }
+  static async SearchSelect(opts) {
+    return search(opts);
+  }
+  static SettingsPath(storagePath) {
+    return `${storagePath}${path.sep}settings.json`;
+  }
+  async LoadSettings(type, storagePath) {
+    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);
+        // Convert string representations back to BigInt where needed
+        this.settings = await this.decryptSettings(parsed.settings);
+        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, value) {
+    if (typeof value === "string" && /^\d+n$/.test(value)) {
+      return BigInt(value.slice(0, -1));
+    }
+    return value;
+  }
+  static bigIntReplacer(_key, value) {
+    return typeof value === "bigint" ? `${value.toString()}n` : value;
+  }
+  static collectSensitivePaths(type, prefix = "") {
+    const paths = [];
+    if (isObject(type)) {
+      const fields = type["properties"];
+      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;
+  }
+  static getNestedValue(obj, path) {
+    return path.split(".").reduce((o, k) => o?.[k], obj);
+  }
+  static setNestedValue(obj, path, value) {
+    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;
+    }
+  }
+  encryptSettings(settings) {
+    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;
+  }
+  async decryptSettings(settings) {
+    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() {
+    this.saveProfile();
+  }
+  async TxDialog(blaze, tx, opts) {
+    const txCbor = tx.toCbor();
+    let expanded = false;
+    const showDialog = async () => {
+      if (expanded) {
+        console.log("Transaction CBOR:", txCbor);
+      } else {
+        console.log("Transaction CBOR:", `${String(txCbor).slice(0, 50)}...`);
+      }
+      const menuItems = [];
+      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;
+              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.message}`);
+            }
+            let signedTx;
+            if (needsStakeKey) {
+              const signed = await blaze.wallet.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 = {
+        title: "Transaction Menu",
+        items: menuItems
+      };
+      await this._showMenu(txMenu, false);
+    };
+    await showDialog();
+  }
+  async EditStruct(type, current) {
+    return this._editStruct(type, ["root"], current);
+  }
+  async _editStruct(type, path, current) {
+    if (isObject(type)) {
+      const obj = {};
+      const fields = type["properties"];
+      const menuItems = [];
+      const currentRecord = current;
+      for (const [field, fieldType] of Object.entries(fields)) {
+        if (current && field in currentRecord) {
+          obj[field] = currentRecord[field];
+        }
+        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 => {
+              obj[field] = undefined;
+              return sprinkle;
+            }
+          });
+        }
+        menuItems.push({
+          title: menuTitle,
+          action: async sprinkle => {
+            const fieldValue = await sprinkle._editStruct(fieldType, path.concat([field]), current && field in currentRecord ? currentRecord[field] : undefined);
+            obj[field] = fieldValue;
+            return sprinkle;
+          }
+        });
+      }
+      const editMenu = {
+        title: "Test",
+        items: menuItems
+      };
+      await this._showMenu(editMenu, false);
+      return obj;
+    }
+    return this._fillInStruct(type, path, {}, current);
+  }
+  async FillInStruct(type, def) {
+    return this._fillInStruct(type, ["root"], {}, def);
+  }
+  async _fillInStruct(type, path, defs, def) {
+    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);
+    }
+    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;
+      }
+      // Unwrap the optional and fill the inner type
+      const innerType = {
+        ...type
+      };
+      delete innerType[OptionalKind];
+      return this._fillInStruct(innerType, 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);
+    }
+    if (isString(type)) {
+      const defaultString = def ? def : this.defaults["string"];
+      const message = Sprinkle.ExtractMessage(type, `Enter a string for ${path.join(".")}`);
+      let answer;
+      if (isSensitive(type)) {
+        answer = await password({
+          message
+        });
+      } else {
+        answer = await input({
+          message,
+          default: defaultString
+        });
+        this.defaults["string"] = answer;
+      }
+      return answer;
+    }
+    if (isBigInt(type)) {
+      const answer = await input({
+        message: Sprinkle.ExtractMessage(type, `Enter a bigint for ${path.join(".")}`),
+        default: def ? def.toString() : undefined,
+        validate: s => {
+          try {
+            BigInt(s);
+            return true;
+          } catch {
+            return "Please enter a valid bigint.";
+          }
+        }
+      });
+      return BigInt(answer);
+    }
+    if (isLiteral(type)) {
+      return type.const;
+    }
+    if (isObject(type)) {
+      const obj = {};
+      const fields = type["properties"];
+      for (const [field, fieldType] of Object.entries(fields)) {
+        const fieldValue = await this._fillInStruct(fieldType, path.concat([field]), defs, def ? def[field] : undefined);
+        obj[field] = fieldValue;
+      }
+      return obj;
+    }
+
+    //TODO: support starting with default values for arrays and allow removal of items
+    if (isArray(type)) {
+      const arr = [];
+      const itemType = type.items;
+      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;
+    }
+    throw new Error(`Unable to fill in struct for type at path ${path.join(".")}`);
+  }
+  resolveType(type, path, defs) {
+    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);
+    }
+    return type;
+  }
+  static ExtractMessage(type, def) {
+    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"];
+      if ("type" in fields) {
+        return Sprinkle.ExtractMessage(fields["type"], def);
+      }
+      const fieldNames = Object.keys(fields);
+      if (fieldNames.length === 1) {
+        return fieldNames[0];
+      }
+    }
+    return def;
+  }
+}
+//# sourceMappingURL=index.js.map