Merge pull request #381 from relaystr/feat/gift-wrap-custom-signer

Feat: gift wrap add custom signer parameter

Author: nogringo

packages/ndk/lib/domain_layer/usecases/gift_wrap/gift_wrap.dart

@@ -3,6 +3,7 @@ import 'dart:convert';
 import '../../../data_layer/models/nip_01_event_model.dart';
 import '../../../data_layer/repositories/signers/bip340_event_signer.dart';
 import '../../entities/nip_01_event.dart';
+import '../../repositories/event_signer.dart';
 import '../accounts/accounts.dart';
 import '../../../shared/nips/nip01/bip340.dart';
 
@@ -14,16 +15,34 @@ class GiftWrap {
 
   GiftWrap({required this.accounts});
 
+  /// Returns the signer to use for signing operations.
+  /// Uses [customSigner] if provided, otherwise falls back to logged-in account's signer.
+  EventSigner _getSigner({EventSigner? customSigner}) {
+    if (customSigner != null) {
+      return customSigner;
+    }
+    final account = accounts.getLoggedAccount();
+    if (account == null) {
+      throw Exception("cannot sign without account or custom signer");
+    }
+    return account.signer;
+  }
+
   /// converts a Nip01Event to a giftWrap Nip01Event \
   /// [rumor] the event you want to wrap \
   /// [recipientPubkey] the reciever of the rumor \
+  /// [customSigner] optional signer to use instead of the logged-in account's signer \
   /// [returns] the wrapped event
   Future<Nip01Event> toGiftWrap({
     required Nip01Event rumor,
     required String recipientPubkey,
+    EventSigner? customSigner,
   }) async {
-    final sealedRumor =
-        await sealRumor(rumor: rumor, recipientPubkey: recipientPubkey);
+    final sealedRumor = await sealRumor(
+      rumor: rumor,
+      recipientPubkey: recipientPubkey,
+      customSigner: customSigner,
+    );
 
     final giftWrap = await wrapEvent(
       recipientPublicKey: recipientPubkey,
@@ -34,16 +53,24 @@ class GiftWrap {
 
   /// Unwraps a gift-wrapped event to retrieve the original rumor \
   /// [giftWrap] the gift-wrapped event to unwrap \
+  /// [customSigner] optional signer to use instead of the logged-in account's signer \
   /// [returns] the original rumor event
   Future<Nip01Event> fromGiftWrap({
     required Nip01Event giftWrap,
+    EventSigner? customSigner,
   }) async {
     if (giftWrap.kind != kGiftWrapEventkind) {
       throw Exception("Event is not a gift wrap (kind:1059)");
     }
 
-    final sealEvent = await unwrapEvent(wrappedEvent: giftWrap);
-    final rumor = await unsealRumor(sealedEvent: sealEvent);
+    final sealEvent = await unwrapEvent(
+      wrappedEvent: giftWrap,
+      customSigner: customSigner,
+    );
+    final rumor = await unsealRumor(
+      sealedEvent: sealEvent,
+      customSigner: customSigner,
+    );
 
     return rumor;
   }
@@ -75,16 +102,15 @@ class GiftWrap {
 
   /// Seals a rumor (creates a kind:13 event)
   ///
+  /// [customSigner] optional signer to use instead of the logged-in account's signer
   Future<Nip01Event> sealRumor({
     required Nip01Event rumor,
     required String recipientPubkey,
+    EventSigner? customSigner,
   }) async {
-    final account = accounts.getLoggedAccount();
-    if (account == null) {
-      throw Exception("cannot sign without account");
-    }
+    final signer = _getSigner(customSigner: customSigner);
 
-    final encryptedContent = await account.signer.encryptNip44(
+    final encryptedContent = await signer.encryptNip44(
       plaintext: Nip01EventModel.fromEntity(rumor).toJsonString(),
       recipientPubKey: recipientPubkey,
     );
@@ -94,7 +120,7 @@ class GiftWrap {
     }
 
     final sealEvent = Nip01Event(
-      pubKey: account.pubkey,
+      pubKey: signer.getPublicKey(),
       kind: kSealEventKind,
       tags: [],
       content: encryptedContent,
@@ -103,15 +129,17 @@ class GiftWrap {
     return sealEvent;
   }
 
+  /// Unseals a sealed event to retrieve the rumor
+  ///
+  /// [customSigner] optional signer to use instead of the logged-in account's signer
   Future<Nip01Event> unsealRumor({
     required Nip01Event sealedEvent,
+    EventSigner? customSigner,
   }) async {
-    final account = accounts.getLoggedAccount();
-    if (account == null) {
-      throw Exception("Cannot decrypt without account");
-    }
+    final signer = _getSigner(customSigner: customSigner);
+
     // Now decrypt the seal to get the rumor
-    final decryptedRumorJson = await account.signer.decryptNip44(
+    final decryptedRumorJson = await signer.decryptNip44(
       ciphertext: sealedEvent.content,
       senderPubKey: sealedEvent.pubKey,
     );
@@ -180,15 +208,16 @@ class GiftWrap {
     return gWEventSigned;
   }
 
+  /// Unwraps a gift wrap to get the seal event
+  ///
+  /// [customSigner] optional signer to use instead of the logged-in account's signer
   Future<Nip01Event> unwrapEvent({
     required Nip01Event wrappedEvent,
+    EventSigner? customSigner,
   }) async {
-    final account = accounts.getLoggedAccount();
-    if (account == null) {
-      throw Exception("Cannot decrypt without account");
-    }
+    final signer = _getSigner(customSigner: customSigner);
 
-    final decryptedEventJson = await account.signer.decryptNip44(
+    final decryptedEventJson = await signer.decryptNip44(
       ciphertext: wrappedEvent.content,
       senderPubKey: wrappedEvent.pubKey,
     );

packages/ndk/test/usecases/gift_wrap/gift_wrap_test.dart

@@ -11,6 +11,7 @@ void main() {
   // Test keys
   final key1 = Bip340.generatePrivateKey();
   final key2 = Bip340.generatePrivateKey();
+  final key3 = Bip340.generatePrivateKey(); // For custom signer tests
 
   setUp(() {
     ndk = Ndk(
@@ -111,5 +112,73 @@ void main() {
               .any((tag) => tag[0] == 'client' && tag[1] == 'test_client'),
           isTrue);
     });
+
+    test(
+        'Can use custom signer instead of logged-in account for wrap and unwrap',
+        () async {
+      // Create a custom signer with key3 (different from logged-in key1)
+      final customSigner = Bip340EventSigner(
+        privateKey: key3.privateKey,
+        publicKey: key3.publicKey,
+      );
+
+      // Create a rumor with custom pubkey matching the custom signer
+      final originalRumor = await giftWrapService.createRumor(
+        customPubkey: key3.publicKey,
+        content: 'Test message with custom signer',
+        kind: 1,
+        tags: [],
+      );
+
+      // Wrap the rumor using the custom signer (not the logged-in account)
+      final giftWrap = await giftWrapService.toGiftWrap(
+        rumor: originalRumor,
+        recipientPubkey: key2.publicKey,
+        customSigner: customSigner,
+      );
+
+      // Create a signer for the recipient to unwrap
+      final recipientSigner = Bip340EventSigner(
+        privateKey: key2.privateKey,
+        publicKey: key2.publicKey,
+      );
+
+      // Unwrap using the custom signer (without switching logged-in account)
+      final unwrappedRumor = await giftWrapService.fromGiftWrap(
+        giftWrap: giftWrap,
+        customSigner: recipientSigner,
+      );
+
+      // Verify the unwrapped rumor matches the original
+      expect(unwrappedRumor.content, equals(originalRumor.content));
+      expect(unwrappedRumor.kind, equals(originalRumor.kind));
+      expect(unwrappedRumor.pubKey, equals(key3.publicKey));
+    });
+
+    test('Custom signer seal uses correct pubkey', () async {
+      // Create a custom signer
+      final customSigner = Bip340EventSigner(
+        privateKey: key3.privateKey,
+        publicKey: key3.publicKey,
+      );
+
+      // Create a rumor
+      final rumor = await giftWrapService.createRumor(
+        customPubkey: key3.publicKey,
+        content: 'Test seal pubkey',
+        kind: 1,
+        tags: [],
+      );
+
+      // Seal using the custom signer
+      final seal = await giftWrapService.sealRumor(
+        rumor: rumor,
+        recipientPubkey: key2.publicKey,
+        customSigner: customSigner,
+      );
+
+      // Verify the seal uses the custom signer's pubkey
+      expect(seal.pubKey, equals(key3.publicKey));
+    });
   });
 }