@sundaeswap/sprinkles 0.1.1 → 0.2.0

package/src/Sprinkle/index.ts

@@ -6,7 +6,7 @@ import {
   HotWallet,
   type Wallet,
 } from "@blaze-cardano/sdk";
-import { CborSet, VkeyWitness } from "@blaze-cardano/core";
+import { CborSet, VkeyWitness, blake2b_256, TxCBOR } from "@blaze-cardano/core";
 import { confirm, input, password, search, select } from "@inquirer/prompts";
 import {
   Kind,
@@ -72,6 +72,16 @@ export interface IProfileEntry {
   meta: IProfileMeta;
 }
 
+export interface TxDialogResult {
+  action: "submitted" | "signed" | "cancelled";
+  txId?: string; // present only if action === 'submitted'
+  tx: Core.Transaction; // the (potentially signed) transaction
+}
+
+export interface TxDialogOptions {
+  beforeSign?: () => Promise<void>;
+}
+
 export const NetworkSchema = Type.Union([
   Type.Literal("mainnet"),
   Type.Literal("preview"),
@@ -803,152 +813,380 @@ export class Sprinkle<S extends TSchema> {
     this.saveProfile();
   }
 
+  // --- TxDialog Helpers ---
+
+  /**
+   * Get the payment key hash from a HotWallet's first address
+   */
+  private async getWalletPaymentKeyHash(
+    wallet: HotWallet,
+  ): Promise<string | null> {
+    try {
+      const addresses = await wallet.getUsedAddresses();
+      const address = addresses[0];
+      if (!address) return null;
+      const paymentCredential = address.asBase()?.getPaymentCredential();
+      return paymentCredential?.hash?.toString() ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Count the number of vkey signatures in a transaction's witness set
+   */
+  private countSignatures(tx: Core.Transaction): number {
+    const vkeys = tx.witnessSet().vkeys();
+    return vkeys ? vkeys.size() : 0;
+  }
+
+  /**
+   * Check if a specific public key has already signed the transaction
+   * Compares by vkey (public key bytes)
+   */
+  private hasVkeySigned(tx: Core.Transaction, vkeyHex: string): boolean {
+    const vkeys = tx.witnessSet().vkeys();
+    if (!vkeys) return false;
+    const vkeyArray = vkeys.toCore();
+    return vkeyArray.some(([vkey]) => vkey === vkeyHex);
+  }
+
+  /**
+   * Get the list of required signer key hashes from the transaction body
+   */
+  private getRequiredSigners(tx: Core.Transaction): string[] {
+    const requiredSigners = tx.body().requiredSigners();
+    if (!requiredSigners) return [];
+    return Array.from(requiredSigners.values()).map((s) => s.toString());
+  }
+
+  /**
+   * Compute the transaction body hash for display
+   */
+  private getTxBodyHash(tx: Core.Transaction): string {
+    const bodyCbor = tx.body().toCbor();
+    return blake2b_256(bodyCbor);
+  }
+
+  /**
+   * Format a hash for display: first 8 chars + ... + last 8 chars
+   */
+  private formatHash(hash: string): string {
+    if (hash.length <= 20) return hash;
+    return `${hash.slice(0, 8)}...${hash.slice(-8)}`;
+  }
+
+  /**
+   * Merge signatures from source transaction into target transaction.
+   * Prevents duplicate signatures by comparing vkey (public key).
+   * Returns the count of newly added signatures.
+   */
+  private mergeSignatures(
+    target: Core.Transaction,
+    source: Core.Transaction,
+  ): number {
+    const targetWs = target.witnessSet();
+    const sourceWs = source.witnessSet();
+
+    const targetVkeys = targetWs.vkeys()?.toCore() ?? [];
+    const sourceVkeys = sourceWs.vkeys()?.toCore() ?? [];
+
+    // Find vkeys in source that aren't in target (by comparing public key)
+    const existingPubKeys = new Set(targetVkeys.map(([vkey]) => vkey));
+    const newVkeys = sourceVkeys.filter(
+      ([vkey]) => !existingPubKeys.has(vkey),
+    );
+
+    if (newVkeys.length === 0) {
+      return 0;
+    }
+
+    // Merge the new vkeys into target
+    targetWs.setVkeys(
+      CborSet.fromCore([...targetVkeys, ...newVkeys], VkeyWitness.fromCore),
+    );
+    target.setWitnessSet(targetWs);
+
+    return newVkeys.length;
+  }
+
   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();
+    opts?: TxDialogOptions,
+  ): Promise<TxDialogResult> {
+    let currentTx = tx;
     let expanded = false;
+    let hasSignedThisSession = false;
+
+    // Check if wallet can sign (is HotWallet)
+    const isHotWallet = blaze.wallet instanceof HotWallet;
 
-    const showDialog = async (): Promise<void> => {
+    // Get wallet's vkeys for detecting if already signed
+    let walletVkeys: string[] = [];
+    if (isHotWallet) {
+      try {
+        // Sign a dummy to get the wallet's public keys
+        // We'll use this to check if wallet has already signed
+        const wallet = blaze.wallet as unknown as HotWallet;
+        const addresses = await wallet.getUsedAddresses();
+        const address = addresses[0];
+        if (address) {
+          // We can't easily get vkeys without signing, so we'll track after first sign
+        }
+      } catch {
+        // Ignore errors in setup
+      }
+    }
+
+    while (true) {
+      // Display transaction status
+      const txHash = this.getTxBodyHash(currentTx);
+      const sigCount = this.countSignatures(currentTx);
+      const requiredSigners = this.getRequiredSigners(currentTx);
+
+      console.log("");
+      console.log(`Transaction: ${this.formatHash(txHash)}`);
+      if (requiredSigners.length > 0) {
+        console.log(`Signatures: ${sigCount} of ${requiredSigners.length} required`);
+        console.log("Required signers:");
+        for (const signer of requiredSigners) {
+          console.log(`  - ${this.formatHash(signer)}`);
+        }
+      } else {
+        console.log(`Signatures: ${sigCount}`);
+      }
+
+      // Display CBOR
+      const txCbor = currentTx.toCbor();
       if (expanded) {
         console.log("Transaction CBOR:", txCbor);
       } else {
         console.log("Transaction CBOR:", `${String(txCbor).slice(0, 50)}...`);
       }
 
-      const menuItems: TMenuItem<S>[] = [];
+      // Build dynamic menu choices
+      const choices: { name: string; value: string }[] = [];
 
+      // "Sign with this wallet" - only if HotWallet and hasn't signed this session
+      if (isHotWallet && !hasSignedThisSession) {
+        choices.push({ name: "Sign with this wallet", value: "sign" });
+      }
+
+      // CBOR options
       if (!expanded) {
-        menuItems.push({
-          title: "Expand CBOR",
-          action: async () => {
-            expanded = true;
-            await showDialog();
-          },
-        });
+        choices.push({ name: "Expand CBOR", value: "expand" });
       }
+      choices.push({ name: "Copy CBOR to clipboard", value: "copy" });
+      choices.push({ name: "Import signatures from CBOR", value: "import" });
 
-      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();
-          }
-        },
+      // Submit and cancel
+      choices.push({ name: "Submit transaction", value: "submit" });
+      choices.push({ name: "Cancel", value: "cancel" });
+
+      const selection = await select({
+        message: "Select an option:",
+        choices,
       });
 
-      if (blaze.wallet instanceof HotWallet) {
-        menuItems.push({
-          title: "Sign and submit transaction",
-          action: async () => {
-            if (opts?.beforeSign) {
-              await opts.beforeSign();
-            }
+      // Handle selection
+      if (selection === "sign") {
+        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;
-                  }
-                }
+        // 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 reqSigners = currentTx.body().requiredSigners();
+              if (reqSigners) {
+                const signerArray = Array.from(reqSigners.values());
+                needsStakeKey = signerArray.some(
+                  (signer) => signer.toString() === stakeKeyHash,
+                );
               }
 
-              if (needsStakeKey) {
-                console.log("Transaction requires stake key signature.");
-              } else {
-                console.log("Transaction requires payment key signature only.");
+              const certs = currentTx.body().certs();
+              const hasCertificates = certs && certs.size() > 0;
+              const withdrawals = currentTx.body().withdrawals();
+              const hasWithdrawals = withdrawals && withdrawals.size > 0;
+
+              if (hasCertificates || hasWithdrawals) {
+                needsStakeKey = true;
               }
-            } 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() ?? [];
+          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}`);
+        }
 
-              const signedKeys = signed.vkeys();
-              if (!signedKeys) {
-                throw new Error(
-                  "signTransaction: no signed keys in wallet witness response",
-                );
-              }
+        try {
+          if (needsStakeKey) {
+            const wallet = blaze.wallet as unknown as HotWallet;
+            const signed = await wallet.signTransaction(currentTx, true, true);
+            const ws = currentTx.witnessSet();
+            const existingVkeys = 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",
-                );
-              }
+            // Check for duplicates before adding
+            const newSignedKeys = signedKeys.toCore();
+            const existingPubKeys = new Set(existingVkeys.map(([vkey]) => vkey));
+            const uniqueNewKeys = newSignedKeys.filter(
+              ([vkey]) => !existingPubKeys.has(vkey),
+            );
 
+            if (uniqueNewKeys.length === 0) {
+              console.log("Wallet has already signed this transaction.");
+            } else {
               ws.setVkeys(
                 CborSet.fromCore(
-                  [...signedKeys.toCore(), ...vkeys],
+                  [...existingVkeys, ...uniqueNewKeys],
                   VkeyWitness.fromCore,
                 ),
               );
-              tx.setWitnessSet(ws);
-              signedTx = tx;
+              currentTx.setWitnessSet(ws);
+              console.log(`Added ${uniqueNewKeys.length} signature(s).`);
+              hasSignedThisSession = true;
+            }
+          } else {
+            const signedTx = await blaze.signTransaction(currentTx);
+            // Merge signatures from signed tx into current tx
+            const added = this.mergeSignatures(currentTx, signedTx);
+            if (added > 0) {
+              console.log(`Added ${added} signature(s).`);
+              hasSignedThisSession = true;
             } else {
-              signedTx = await blaze.signTransaction(tx);
+              console.log("Wallet has already signed this transaction.");
             }
+          }
+        } catch (error) {
+          console.error(`Signing failed: ${(error as Error).message}`);
+        }
+        // Continue loop after signing
+        continue;
+      }
 
-            const txId = await blaze.submitTransaction(signedTx);
-            console.log(`Transaction submitted: ${txId}`);
-          },
+      if (selection === "expand") {
+        expanded = true;
+        continue;
+      }
+
+      if (selection === "copy") {
+        try {
+          const { default: clipboard } = await import("clipboardy");
+          clipboard.writeSync(String(currentTx.toCbor()));
+          console.log("Transaction CBOR copied to clipboard.");
+        } catch {
+          console.log("Failed to copy to clipboard, expanding instead.");
+          expanded = true;
+        }
+        continue;
+      }
+
+      if (selection === "import") {
+        const cborInput = await input({
+          message: "Paste transaction CBOR (hex):",
         });
+
+        if (!cborInput || cborInput.trim() === "") {
+          console.log("No CBOR provided.");
+          continue;
+        }
+
+        try {
+          const importedTx = Core.Transaction.fromCbor(
+            TxCBOR(cborInput.trim()),
+          );
+
+          // Validate body hash matches
+          const currentHash = this.getTxBodyHash(currentTx);
+          const importedHash = this.getTxBodyHash(importedTx);
+
+          if (currentHash !== importedHash) {
+            const proceed = await confirm({
+              message: `Warning: Imported transaction has different body hash.\nCurrent:  ${this.formatHash(currentHash)}\nImported: ${this.formatHash(importedHash)}\nProceed anyway?`,
+              default: false,
+            });
+            if (!proceed) {
+              console.log("Import cancelled.");
+              continue;
+            }
+          }
+
+          // Merge signatures
+          const added = this.mergeSignatures(currentTx, importedTx);
+          const sourceVkeys = importedTx.witnessSet().vkeys();
+          const sourceCount = sourceVkeys ? sourceVkeys.size() : 0;
+          const skipped = sourceCount - added;
+
+          if (added > 0) {
+            console.log(`Added ${added} new signature(s).`);
+          }
+          if (skipped > 0) {
+            console.log(`Skipped ${skipped} duplicate signature(s).`);
+          }
+          if (added === 0 && skipped === 0) {
+            console.log("No signatures found in imported transaction.");
+          }
+        } catch (error) {
+          console.error(`Failed to import CBOR: ${(error as Error).message}`);
+        }
+        continue;
       }
 
-      const txMenu: IMenu<S> = {
-        title: "Transaction Menu",
-        items: menuItems,
-      };
-      await this._showMenu(txMenu, false);
-    };
+      if (selection === "submit") {
+        const sigCount = this.countSignatures(currentTx);
+        if (sigCount === 0) {
+          const proceed = await confirm({
+            message: "Warning: Transaction has no signatures. Submit anyway?",
+            default: false,
+          });
+          if (!proceed) {
+            continue;
+          }
+        }
 
-    await showDialog();
+        try {
+          const txId = await blaze.submitTransaction(currentTx);
+          console.log(`Transaction submitted: ${txId}`);
+          return { action: "submitted", txId, tx: currentTx };
+        } catch (error) {
+          console.error(`Submit failed: ${(error as Error).message}`);
+          // Continue loop to allow retry or other actions
+          continue;
+        }
+      }
+
+      if (selection === "cancel") {
+        if (hasSignedThisSession) {
+          return { action: "signed", tx: currentTx };
+        }
+        return { action: "cancelled", tx: currentTx };
+      }
+    }
   }
 
   async EditStruct<U extends TSchema>(