@sundaeswap/sprinkles 0.7.0 → 0.8.1

package/src/Sprinkle/index.ts

@@ -58,10 +58,14 @@ export {
   NetworkSchema,
   MultisigScriptModule,
   MultisigScript,
+  NativeScriptInputSchema,
+  NativeScriptsParam,
   ProviderSettingsSchema,
   WalletSettingsSchema,
 } from "./schemas.js";
 export type { TMultisigScript } from "./schemas.js";
+import type { TMultisigScript } from "./schemas.js";
+import { MultisigScript as MultisigScriptSchema } from "./schemas.js";
 
 // Import and re-export type guards
 import {
@@ -170,6 +174,7 @@ import {
   promptAndExecute,
 } from "./actions/index.js";
 import type { AnyAction, IActionContext, IActionResult } from "./actions/index.js";
+import { toNativeScript } from "./actions/index.js";
 export type { IAction, IActionContext, IActionResult, IActionSuccess, IActionFailure, AnyAction } from "./actions/index.js";
 export {
   ActionRegistry,
@@ -191,7 +196,15 @@ export {
   runMcp,
   getBuiltinActions,
   promptAndExecute,
+  toNativeScript,
+  completeWithScripts,
 } from "./actions/index.js";
+export type { NativeScriptInput } from "./actions/index.js";
+import {
+  mintToken,
+  simpleSend,
+  registerStakeScript,
+} from "./actions/builtin/utility-actions.js";
 
 export interface IMenuAction<S extends TSchema> {
   title: string;
@@ -209,6 +222,7 @@ export class Sprinkle<S extends TSchema> {
   settings: TExact<S> = {} as TExact<S>;
   type: S;
   defaults: Record<string, unknown> = {};
+  addressbook: Record<string, TMultisigScript> = {};
   options: ISprinkleOptions;
   profileId: string = "";
   profileMeta: IProfileMeta = { name: "", createdAt: "", updatedAt: "" };
@@ -301,6 +315,7 @@ export class Sprinkle<S extends TSchema> {
     this.profileMeta = parsed.meta;
     this.settings = await this.decryptSettings(parsed.settings as TExact<S>);
     this.defaults = parsed.defaults ?? {};
+    this.addressbook = parsed.addressbook ?? {};
     // Update active profile pointer
     fs.writeFileSync(Sprinkle.activeProfilePath(this.storagePath), id, "utf-8");
   }
@@ -323,6 +338,7 @@ export class Sprinkle<S extends TSchema> {
         meta: this.profileMeta,
         settings: settingsToSave,
         defaults: this.defaults,
+        addressbook: this.addressbook,
       },
       bigIntReplacer,
       2,
@@ -403,6 +419,7 @@ export class Sprinkle<S extends TSchema> {
           },
           settings: parsed.settings,
           defaults: parsed.defaults ?? {},
+          addressbook: parsed.addressbook ?? {},
         };
         fs.mkdirSync(profilesDir, { recursive: true });
         fs.writeFileSync(
@@ -487,6 +504,7 @@ export class Sprinkle<S extends TSchema> {
         meta: { name, description, createdAt: now, updatedAt: now },
         settings: settingsToSave,
         defaults: this.defaults,
+        addressbook: this.addressbook,
       },
       bigIntReplacer,
       2,
@@ -598,6 +616,7 @@ export class Sprinkle<S extends TSchema> {
     if (!main) {
       choices.push({ name: "Back", value: -1 });
     } else {
+      choices.push({ name: "Utilities", value: -6 });
       choices.push({ name: "Settings & Profiles", value: -5 });
       choices.push({ name: "Exit", value: -1 });
     }
@@ -616,6 +635,74 @@ export class Sprinkle<S extends TSchema> {
       return;
     }
     const selection = selectionResult as number;
+    if (selection === -6) {
+      const utilitiesMenu: IMenu<S> = {
+        title: "Utilities",
+        items: [
+          {
+            title: "Mint Token",
+            action: async () => {
+              const result = await promptAndExecute(this, mintToken);
+              if (!result.success) {
+                if (result.error.code === "USER_CANCELLED") return;
+                console.error(`\nError (${result.error.code}): ${result.error.message}\n`);
+                return;
+              }
+              const data = result.data as { txCbor: string; policyId: string; tokenName: string; amount: string };
+              console.log(`\nPolicy: ${data.policyId}\nToken: ${data.tokenName}\nAmount: ${data.amount}\n`);
+              const blaze = await Sprinkle.GetBlaze(
+                (this.settings as Record<string, unknown>).network as TExact<typeof NetworkSchema>,
+                (this.settings as Record<string, unknown>).provider as TExact<typeof ProviderSettingsSchema>,
+                (this.settings as Record<string, unknown>).wallet as TExact<typeof WalletSettingsSchema>,
+              );
+              const tx = Core.Transaction.fromCbor(Core.TxCBOR(data.txCbor));
+              await this.TxDialog(blaze, tx);
+            },
+          },
+          {
+            title: "Simple Send",
+            action: async () => {
+              const result = await promptAndExecute(this, simpleSend);
+              if (!result.success) {
+                if (result.error.code === "USER_CANCELLED") return;
+                console.error(`\nError (${result.error.code}): ${result.error.message}\n`);
+                return;
+              }
+              const data = result.data as { txCbor: string };
+              const blaze = await Sprinkle.GetBlaze(
+                (this.settings as Record<string, unknown>).network as TExact<typeof NetworkSchema>,
+                (this.settings as Record<string, unknown>).provider as TExact<typeof ProviderSettingsSchema>,
+                (this.settings as Record<string, unknown>).wallet as TExact<typeof WalletSettingsSchema>,
+              );
+              const tx = Core.Transaction.fromCbor(Core.TxCBOR(data.txCbor));
+              await this.TxDialog(blaze, tx);
+            },
+          },
+          {
+            title: "Register Stake Script",
+            action: async () => {
+              const result = await promptAndExecute(this, registerStakeScript);
+              if (!result.success) {
+                if (result.error.code === "USER_CANCELLED") return;
+                console.error(`\nError (${result.error.code}): ${result.error.message}\n`);
+                return;
+              }
+              const data = result.data as { txCbor: string };
+              const blaze = await Sprinkle.GetBlaze(
+                (this.settings as Record<string, unknown>).network as TExact<typeof NetworkSchema>,
+                (this.settings as Record<string, unknown>).provider as TExact<typeof ProviderSettingsSchema>,
+                (this.settings as Record<string, unknown>).wallet as TExact<typeof WalletSettingsSchema>,
+              );
+              const tx = Core.Transaction.fromCbor(Core.TxCBOR(data.txCbor));
+              await this.TxDialog(blaze, tx);
+            },
+          },
+        ],
+      };
+      await this._showMenu(utilitiesMenu, false, [...path, "Utilities"], true);
+      await this._showMenu(menu, main, path, true);
+      return;
+    }
     if (selection === -5) {
       const settingsMenu: IMenu<S> = {
         title: "Settings & Profiles",
@@ -689,6 +776,114 @@ export class Sprinkle<S extends TSchema> {
               await this.deleteProfile();
             },
           },
+          {
+            title: "Addressbook",
+            items: [
+              {
+                title: "View entries",
+                action: async () => {
+                  const entries = Object.entries(this.addressbook);
+                  if (entries.length === 0) {
+                    console.log("Addressbook is empty.");
+                  } else {
+                    for (const [name, ms] of entries) {
+                      const json = JSON.stringify(ms, bigIntReplacer, 2);
+                      let hashStr = "unknown";
+                      try {
+                        hashStr = toNativeScript(ms).hash();
+                      } catch { /* skip */ }
+                      console.log(colors.bold(name) + "  " + colors.dim(hashStr));
+                      console.log(json);
+                      console.log();
+                    }
+                  }
+                  await selectWithClear({
+                    message: "Press Enter to continue...",
+                    choices: [{ name: "Continue", value: "continue" }],
+                  });
+                },
+              },
+              {
+                title: "Add entry",
+                action: async () => {
+                  const name = await inputCancellable({
+                    message: "Entry name:",
+                    validate: (v) =>
+                      v.trim().length > 0 ? true : "Name cannot be empty",
+                  });
+                  if (name === null) return;
+                  if (this.addressbook[name]) {
+                    const overwrite = await confirmCancellable({
+                      message: `Entry "${name}" already exists. Overwrite?`,
+                      default: false,
+                    });
+                    if (!overwrite) return;
+                  }
+                  try {
+                    const script = await this.FillInStruct(MultisigScriptSchema);
+                    this.addressbook[name] = script as TMultisigScript;
+                    this.saveSettings();
+                    console.log(`Added "${name}" to addressbook.`);
+                  } catch (e) {
+                    if (e instanceof UserCancelledError) return;
+                    throw e;
+                  }
+                },
+              },
+              {
+                title: "Edit entry",
+                action: async () => {
+                  const entries = Object.keys(this.addressbook);
+                  if (entries.length === 0) {
+                    console.log("Addressbook is empty.");
+                    return;
+                  }
+                  const selected = await selectCancellable({
+                    message: "Select entry to edit:",
+                    choices: entries.map((n) => ({ name: n, value: n })),
+                  });
+                  if (selected === null) return;
+                  const editName = selected as string;
+                  try {
+                    const updated = await this.EditStruct(
+                      MultisigScriptSchema,
+                      this.addressbook[editName] as any,
+                    );
+                    this.addressbook[editName] = updated as TMultisigScript;
+                    this.saveSettings();
+                    console.log(`Updated "${editName}".`);
+                  } catch (e) {
+                    if (e instanceof UserCancelledError) return;
+                    throw e;
+                  }
+                },
+              },
+              {
+                title: "Delete entry",
+                action: async () => {
+                  const entries = Object.keys(this.addressbook);
+                  if (entries.length === 0) {
+                    console.log("Addressbook is empty.");
+                    return;
+                  }
+                  const delSelected = await selectCancellable({
+                    message: "Select entry to delete:",
+                    choices: entries.map((n) => ({ name: n, value: n })),
+                  });
+                  if (delSelected === null) return;
+                  const delName = delSelected as string;
+                  const confirmed = await confirmCancellable({
+                    message: `Delete "${delName}"?`,
+                    default: false,
+                  });
+                  if (!confirmed) return;
+                  delete this.addressbook[delName];
+                  this.saveSettings();
+                  console.log(`Deleted "${delName}".`);
+                },
+              },
+            ],
+          } as IMenu<S>,
         ],
       };
       await this._showMenu(settingsMenu, false, [...path, "Settings & Profiles"], true);
@@ -869,6 +1064,7 @@ export class Sprinkle<S extends TSchema> {
       meta,
       settings: initialSettings ?? {},
       defaults: {},
+      addressbook: {},
     };
 
     fs.writeFileSync(
@@ -1242,9 +1438,58 @@ export class Sprinkle<S extends TSchema> {
           `Could not resolve type ${type["$ref"]} at ${path.join(".")}`,
         );
       }
-      return this._fillInStruct(resolvedType, path, defs, def) as Promise<
-        TExact<U>
-      >;
+
+      // Addressbook integration for MultisigScript fields
+      if (type["$ref"] === "MultisigScript" && Object.keys(this.addressbook).length > 0) {
+        const sourceChoice = await selectWithClear({
+          message: "Select source for native script:",
+          choices: [
+            { name: "Enter manually", value: "manual" },
+            { name: "Select from addressbook", value: "addressbook" },
+          ],
+        });
+        if (sourceChoice === null) throw new UserCancelledError();
+        if (sourceChoice === "addressbook") {
+          const entries = Object.entries(this.addressbook);
+          const abChoices = entries.map(([name, ms]) => {
+            let hashStr = "";
+            try { hashStr = "  " + colors.dim(toNativeScript(ms).hash()); } catch { /* skip */ }
+            return { name: name + hashStr, value: name };
+          });
+          const selected = await selectWithClear({
+            message: "Select addressbook entry:",
+            choices: abChoices,
+          });
+          if (selected === null) throw new UserCancelledError();
+          return this.addressbook[selected as string] as TExact<U>;
+        }
+      }
+
+      const result = await this._fillInStruct(resolvedType, path, defs, def) as TExact<U>;
+
+      // Offer to save manually entered MultisigScript to addressbook
+      if (type["$ref"] === "MultisigScript" && result !== undefined) {
+        const shouldSave = await selectWithClear({
+          message: "Save this script to the addressbook?",
+          choices: [
+            { name: "No", value: false },
+            { name: "Yes", value: true },
+          ],
+        });
+        if (shouldSave) {
+          const entryName = await inputCancellable({
+            message: "Addressbook entry name:",
+            validate: (v) => v.trim().length > 0 ? true : "Name cannot be empty",
+          });
+          if (entryName !== null) {
+            this.addressbook[entryName] = result as TMultisigScript;
+            this.saveSettings();
+            console.log(`Saved "${entryName}" to addressbook.`);
+          }
+        }
+      }
+
+      return result;
     }
     if (isOptional(type)) {
       const pathDisplay = formatPath(path) || "value";
@@ -1401,6 +1646,22 @@ export class Sprinkle<S extends TSchema> {
       return BigInt(answer) as TExact<U>;
     }
 
+    if (isBoolean(type)) {
+      const pathDisplay = formatPath(path) || "value";
+      const answer = await selectWithClear({
+        message: Sprinkle.ExtractMessage(type, `${pathDisplay}?`),
+        choices: [
+          { name: "Yes", value: true },
+          { name: "No", value: false },
+        ],
+        default: def !== undefined ? (def as boolean) : hasDefault(type) ? getDefault(type) : undefined,
+      });
+      if (answer === null) {
+        throw new UserCancelledError();
+      }
+      return answer as TExact<U>;
+    }
+
     if (isLiteral(type)) {
       return type.const as TExact<U>;
     }

package/src/Sprinkle/schemas.ts

@@ -78,6 +78,26 @@ export const MultisigScriptModule = Type.Module({
 export const MultisigScript = MultisigScriptModule.Import("MultisigScript");
 export type TMultisigScript = TExact<typeof MultisigScript>;
 
+/**
+ * Native script input schema: accepts either a CBOR hex string or a MultisigScript JSON structure.
+ * Use as an optional array parameter on actions that build transactions.
+ */
+export const NativeScriptInputSchema = Type.Union([
+  Type.String({ description: "Native script CBOR hex" }),
+  MultisigScript,
+]);
+
+/**
+ * Optional array of native scripts to attach to a transaction.
+ * Reusable schema fragment for action input definitions.
+ */
+export const NativeScriptsParam = Type.Optional(
+  Type.Array(NativeScriptInputSchema, {
+    description:
+      "Native scripts to attach to the transaction witness set (CBOR hex or MultisigScript JSON)",
+  }),
+);
+
 /**
  * Provider settings schema for blockchain data providers.
  */