fix: add wrapped func

Author: ieow

src/nobleEncryption.ts

@@ -33,6 +33,15 @@ export const NobleEciesToEcies = (nobleEcies: NobleEcies): Ecies => {
   };
 };
 
+export const EciesToNobleEcies = (ecies: Ecies): NobleEcies => {
+  return {
+    iv: new Uint8Array(ecies.iv),
+    ephemPublicKey: new Uint8Array(ecies.ephemPublicKey),
+    ciphertext: new Uint8Array(ecies.ciphertext),
+    mac: new Uint8Array(ecies.mac),
+  };
+};
+
 export const hmacSha256Sign = (key: Uint8Array, msg: Uint8Array) => {
   const mac = hmac(sha256, key, msg);
   return mac;
@@ -46,7 +55,7 @@ export function hmacSha256Verify(key: Uint8Array, msg: Uint8Array, sig: Uint8Arr
 export const nobleEncrypt = async function (
   publicKeyTo: Uint8Array,
   msg: Uint8Array,
-  opts?: { iv?: Uint8Array; ephemPrivateKey?: Uint8Array; padding?: boolean }
+  opts?: { iv?: Uint8Array; ephemPrivateKey?: Uint8Array }
 ): Promise<NobleEcies> {
   const ephemPrivateKey = opts?.ephemPrivateKey || utils.randomPrivateKey();
   const ephemPublicKey = getPublicKey(ephemPrivateKey, false);
@@ -106,3 +115,19 @@ export const nobleDecrypt = async function (privateKey: Uint8Array, opts: NobleE
 
   return decrypted;
 };
+
+export const encrypt = async function (
+  publicKeyTo: Buffer,
+  msg: Buffer,
+  opts?: { iv?: Buffer; ephemPrivateKey?: Buffer; padding?: boolean }
+): Promise<Ecies> {
+  if (opts?.padding !== undefined) throw new Error("padding opts is not supported");
+  const nobleEcies = await nobleEncrypt(publicKeyTo, msg, opts);
+  return NobleEciesToEcies(nobleEcies);
+};
+
+export const decrypt = async function (privateKey: Buffer, opts: Ecies, padding?: boolean): Promise<Buffer> {
+  const nobleEcies = EciesToNobleEcies(opts);
+  const decrypted = await nobleDecrypt(privateKey, nobleEcies, padding);
+  return Buffer.from(decrypted);
+};

test/encrypt&decrypt.spec.ts

@@ -1,11 +1,10 @@
 /* eslint-disable import/no-extraneous-dependencies */
 import { bytesToUtf8 } from "@noble/ciphers/utils";
-import { sha512 as nobleSha512 } from "@noble/hashes/sha2";
-import { getPublicKey, getSharedSecret } from "@noble/secp256k1";
+import { getPublicKey } from "@noble/secp256k1";
 import { beforeEach, describe, expect, it } from "vitest";
 
 import * as eccrypto from "../src/index";
-import { nobleDecrypt, NobleEciesToEcies, nobleEncrypt } from "../src/nobleEncryption";
+import { decrypt, encrypt, nobleDecrypt, NobleEciesToEcies, nobleEncrypt } from "../src/nobleEncryption";
 
 describe("Functions: encrypt & decrypt", () => {
   let ephemPublicKey: Buffer;
@@ -202,13 +201,23 @@ describe("Functions: encrypt & decrypt", () => {
         ephemPrivateKey: ephemPrivateKey,
       });
 
+      const wrappedEncrypted = await encrypt(publicKey, Buffer.from(message), {
+        iv: iv,
+        ephemPrivateKey: ephemPrivateKey,
+      });
+
       expect(convertedEcies).toEqual(encrypted);
 
+      expect(wrappedEncrypted).toEqual(encrypted);
+
       const decrypted = await nobleDecrypt(privateKey, nobleEcies);
       expect(bytesToUtf8(decrypted)).toBe(message);
 
       const decrypted1 = await eccrypto.decrypt(privateKey, convertedEcies);
       expect(bytesToUtf8(decrypted1)).toBe(message);
+
+      const wrappedDecrypted = await decrypt(privateKey, encrypted);
+      expect(bytesToUtf8(wrappedDecrypted)).toBe(message);
     });
   });
 });