@sundaeswap/sprinkles 0.3.0 → 0.5.0

package/src/Sprinkle/type-guards.ts

@@ -0,0 +1,51 @@
+/**
+ * Type guard utilities for TypeBox schema types.
+ * These are internal helpers used by FillInStruct, encryption, and other modules.
+ */
+
+import {
+  Kind,
+  type TBigInt,
+  type TLiteral,
+  type TObject,
+  type TSchema,
+  type TString,
+  type TTuple,
+  type TUnion,
+  type TArray,
+  type TThis,
+  type TRef,
+  type TImport,
+  type TOptional,
+  OptionalKind,
+} from "@sinclair/typebox";
+
+export const isOptional = <T extends TSchema>(t: T): t is TOptional<T> =>
+  t[OptionalKind] === "Optional";
+
+export const isImport = (t: TSchema): t is TImport => t[Kind] === "Import";
+
+export const isArray = (t: TSchema): t is TArray => t[Kind] === "Array";
+
+export const isBigInt = (t: TSchema): t is TBigInt => t[Kind] === "BigInt";
+
+export const isLiteral = (t: TSchema): t is TLiteral => t[Kind] === "Literal";
+
+export const isObject = (t: TSchema): t is TObject => t[Kind] === "Object";
+
+export const isRef = (t: TSchema): t is TRef => t[Kind] === "Ref";
+
+export const isString = (t: TSchema): t is TString => t[Kind] === "String";
+
+export const isThis = (t: TSchema): t is TThis => t[Kind] === "This";
+
+export const isTuple = (t: TSchema): t is TTuple => t[Kind] === "Tuple";
+
+export const isUnion = (t: TSchema): t is TUnion => t[Kind] === "Union";
+
+/**
+ * Check if a schema field is marked as sensitive.
+ * Sensitive fields are encrypted when saved and masked when displayed.
+ */
+export const isSensitive = (t: TSchema): boolean =>
+  isString(t) && t.sensitive === true;

package/src/Sprinkle/types.ts

@@ -0,0 +1,73 @@
+import { Core } from "@blaze-cardano/sdk";
+import type { Static, TSchema } from "@sinclair/typebox";
+
+/**
+ * Utility type to extract the static type from a TypeBox schema.
+ */
+export type TExact<T> = T extends TSchema ? Static<T> : T;
+
+/**
+ * Options for encrypting/decrypting sensitive fields in settings.
+ */
+export interface IEncryptionOptions {
+  encrypt: (plaintext: string) => string;
+  decrypt: (ciphertext: string) => Promise<string>;
+}
+
+/**
+ * Options for configuring a Sprinkle instance.
+ */
+export interface ISprinkleOptions {
+  encryption?: IEncryptionOptions;
+}
+
+/**
+ * Metadata for a profile.
+ */
+export interface IProfileMeta {
+  name: string;
+  description?: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+/**
+ * Current profile information including ID.
+ */
+export interface ICurrentProfile extends IProfileMeta {
+  id: string;
+}
+
+/**
+ * Profile entry as returned by scanProfiles().
+ */
+export interface IProfileEntry {
+  id: string;
+  meta: IProfileMeta;
+}
+
+/**
+ * Result of the TxDialog interaction.
+ */
+export interface TxDialogResult {
+  action: "submitted" | "signed" | "cancelled";
+  txId?: string; // present only if action === 'submitted'
+  tx: Core.Transaction; // the (potentially signed) transaction
+}
+
+/**
+ * Options for TxDialog.
+ */
+export interface TxDialogOptions {
+  beforeSign?: () => Promise<void>;
+}
+
+/**
+ * Error thrown when user cancels a prompt via Escape key.
+ */
+export class UserCancelledError extends Error {
+  constructor(message: string = "User cancelled the operation") {
+    super(message);
+    this.name = "UserCancelledError";
+  }
+}

package/src/Sprinkle/wallet.ts

@@ -0,0 +1,133 @@
+/**
+ * Wallet and provider setup utilities.
+ * Functions for creating providers, wallets, and Blaze instances.
+ */
+
+import { Blockfrost, type Provider } from "@blaze-cardano/query";
+import {
+  Blaze,
+  ColdWallet,
+  Core,
+  HotWallet,
+  type Wallet,
+} from "@blaze-cardano/sdk";
+import { wordlist } from "@blaze-cardano/core";
+import { confirmCancellable } from "./prompts.js";
+import { UserCancelledError, type TExact } from "./types.js";
+import {
+  NetworkSchema,
+  ProviderSettingsSchema,
+  WalletSettingsSchema,
+} from "./schemas.js";
+
+/**
+ * Creates a blockchain data provider based on settings.
+ */
+export async function 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");
+  }
+}
+
+/**
+ * Creates a wallet instance based on settings.
+ */
+export async function 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");
+  }
+}
+
+/**
+ * Creates a Blaze instance with provider and wallet.
+ */
+export async function GetBlaze(
+  network: TExact<typeof NetworkSchema>,
+  providerSettings: TExact<typeof ProviderSettingsSchema>,
+  walletSettings: TExact<typeof WalletSettingsSchema>,
+): Promise<Blaze<Provider, Wallet>> {
+  const provider = await GetProvider(network, providerSettings);
+  const wallet = await GetWallet(walletSettings, provider);
+  return Blaze.from(provider, wallet);
+}
+
+/**
+ * Generates a new wallet from a BIP39 mnemonic phrase.
+ * Displays the 24-word recovery phrase and requires user confirmation.
+ * @returns The Bip32PrivateKey hex string for storage
+ */
+export async function generateWalletFromMnemonic(): Promise<string> {
+  const mnemonic = Core.generateMnemonic(wordlist, 256); // 24 words
+  const words = mnemonic.split(" ");
+
+  console.log("\n=== NEW WALLET GENERATED ===\n");
+  console.log("IMPORTANT: Save these 24 words in a secure location.");
+  console.log("This is the ONLY way to recover your wallet.\n");
+
+  // Display in 4 columns
+  for (let i = 0; i < 6; i++) {
+    console.log(
+      `${(i + 1).toString().padStart(2)}. ${words[i]!.padEnd(12)} ` +
+        `${(i + 7).toString().padStart(2)}. ${words[i + 6]!.padEnd(12)} ` +
+        `${(i + 13).toString().padStart(2)}. ${words[i + 12]!.padEnd(12)} ` +
+        `${(i + 19).toString().padStart(2)}. ${words[i + 18]}`,
+    );
+  }
+  console.log("");
+
+  const confirmed = await confirmCancellable({
+    message: "Have you saved your recovery phrase?",
+    default: false,
+  });
+
+  if (confirmed === null) {
+    throw new UserCancelledError("Wallet generation cancelled");
+  }
+  if (!confirmed) {
+    throw new Error("Wallet generation cancelled - recovery phrase not saved");
+  }
+
+  const entropy = Core.mnemonicToEntropy(mnemonic, wordlist);
+  const masterKey = Core.Bip32PrivateKey.fromBip39Entropy(
+    Buffer.from(entropy),
+    "",
+  );
+  return masterKey.hex();
+}