rename unwrapKey -> unwrapSymmetricKey

Author: Yannick-Malins

packages/fdc3-security/src/encryption/EncryptingChannelDelegate.ts

@@ -43,7 +43,7 @@ export class EncryptingChannelDelegate extends AbstractChannelDelegate implement
       this.keyUnwrapFunction = keyUnwrapFunction;
     } else {
       if (typeof (fdc3Security as any).unwrapKey === 'function') {
-        this.keyUnwrapFunction = ctx => (fdc3Security as PrivateFDC3Security).unwrapKey(ctx);
+        this.keyUnwrapFunction = ctx => (fdc3Security as PrivateFDC3Security).unwrapSymmetricKey(ctx);
       } else {
         throw new Error(
           'Must provide keyUnwrapFunction or a PrivateFDC3Security implementation that supports unwrapKey'

packages/fdc3-security/src/encryption/EncryptingPrivateChannel.ts

@@ -123,7 +123,7 @@ export interface EncryptingPrivateChannel extends PrivateChannel {
    * @example
    * ```typescript
    * // After receiving a wrapped key response
-   * const unwrappedKey = await security.unwrapKey(wrappedKeyResponse);
+   * const unwrappedKey = await security.unwrapSymmetricKey(wrappedKeyResponse);
    * await channel.setSymmetricKey(unwrappedKey);
    * // Channel can now decrypt incoming messages
    * ```

packages/fdc3-security/src/encryption/SymmetricKeyContextListener.ts

@@ -55,7 +55,7 @@ export function createSymmetricKeyResponseContextListener(
 
       if (ma?.signed && ma.trusted && ma.valid) {
         const skr = context as SymmetricKeyResponse;
-        const key = await fdc3Security.unwrapKey(skr);
+        const key = await fdc3Security.unwrapSymmetricKey(skr);
         if (key) {
           channel.setSymmetricKey(key);
         }

packages/fdc3-security/src/impl/JosePrivateFDC3Security.ts

@@ -111,7 +111,7 @@ export class JosePrivateFDC3Security extends JosePublicFDC3Security implements P
     };
   }
 
-  async unwrapKey(ctx: SymmetricKeyResponse): Promise<JsonWebKey> {
+  async unwrapSymmetricKey(ctx: SymmetricKeyResponse): Promise<JsonWebKey> {
     const key = await jose.importJWK(this.wrappingPrivateKey, this.algorithms.keyWrapping);
     const result = await jose.compactDecrypt(ctx.wrappedKey, key);
     const jsonString = new TextDecoder().decode(result.plaintext);

packages/fdc3-security/src/impl/PrivateFDC3Security.ts

@@ -53,7 +53,7 @@ export interface PrivateFDC3Security extends PublicFDC3Security {
    * @returns A promise resolving to the unwrapped symmetric key in JWK format
    * @throws Error if unwrapping fails
    */
-  unwrapKey(ctx: SymmetricKeyResponse): Promise<JsonWebKey>;
+  unwrapSymmetricKey(ctx: SymmetricKeyResponse): Promise<JsonWebKey>;
 
   /**
    * Create a signed JWT token for user identity.

packages/fdc3-security/test/FDC3Security.test.ts

@@ -179,15 +179,15 @@ describe('JosePrivateFDC3Security', () => {
       const symmetricJWK = await sender.createSymmetricKey();
 
       // Sender wraps the symmetric key for the receiver
-      const wrappedKeyResponse = await sender.wrapKey(symmetricJWK, receiverBaseUrl);
+      const wrappedKeyResponse = await sender.wrapSymmetricKey(symmetricJWK, receiverBaseUrl);
 
       // Verify the wrapped key response structure
       expect(wrappedKeyResponse.type).toBe('fdc3.security.symmetricKeyResponse');
       expect(wrappedKeyResponse.id.pki).toBe(receiverBaseUrl);
       expect(wrappedKeyResponse.wrappedKey).toBeDefined();
 
       // Receiver unwraps the symmetric key
-      const unwrappedKey = await receiver.unwrapKey(wrappedKeyResponse);
+      const unwrappedKey = await receiver.unwrapSymmetricKey(wrappedKeyResponse);
 
       // Verify the unwrapped key matches the original
       expect(unwrappedKey).toEqual(symmetricJWK);