use Buffer.compare instead bufferEqual

Author: hieu-w

package-lock.json

@@ -45,12 +45,10 @@
     "@toruslabs/eslint-config-node": "^4.0.4",
     "@toruslabs/eslint-config-typescript": "^4.0.4",
     "@toruslabs/torus-scripts": "^7.0.4",
-    "@types/buffer-equal": "^1.0.2",
     "@types/elliptic": "^6.4.18",
     "@vitest/browser": "^3.0.7",
     "@vitest/coverage-istanbul": "^3.0.7",
     "browserify": "^17.0.1",
-    "buffer-equal": "^1.0.1",
     "eslint": "^9.21.0",
     "playwright": "^1.50.1",
     "typescript": "^5.7.3",

package.json

@@ -1,5 +1,4 @@
 /* eslint-disable import/no-extraneous-dependencies */
-import bufferEqual from "buffer-equal";
 import { beforeAll, beforeEach, describe, expect, it } from "vitest";
 
 import * as eccrypto from "../src/index";
@@ -99,23 +98,23 @@ describe("Functions: derive & derivePadded", () => {
     });
 
     it("should be equal: derive(privateKeyA, publicKeyB) == derive(privateKeyB, publicKeyA)", async () => {
-      expect(bufferEqual(deriveBA, deriveAB)).toBe(true);
+      expect(Buffer.compare(deriveBA, deriveAB)).toBe(0);
     });
 
     it("should be equal: derive(privateKeyA, publicKeyB) == derivePadded(privateKeyA, publicKeyB)", async () => {
-      expect(bufferEqual(deriveAB, derivePaddedAB)).toBe(true);
+      expect(Buffer.compare(deriveAB, derivePaddedAB)).toBe(0);
     });
 
     it("should be equal: derivePadded(privateKeyA, publicKeyB) == derivePadded(privateKeyB, publicKeyA)", async () => {
-      expect(bufferEqual(derivePaddedBA, derivePaddedAB)).toBe(true);
+      expect(Buffer.compare(derivePaddedBA, derivePaddedAB)).toBe(0);
     });
 
     it("should be equal: derive(privateKeyA, compressedPublicKeyB) == derive(privateKeyB, compressedPublicKeyA)", async () => {
-      expect(bufferEqual(deriveABUseCompressed, deriveBAUseCompressed)).toBe(true);
+      expect(Buffer.compare(deriveABUseCompressed, deriveBAUseCompressed)).toBe(0);
     });
 
     it("should be equal: derive(privateKeyA, compressedPublicKeyB) == derivePadded(privateKeyA, compressedPublicKeyB)", async () => {
-      expect(bufferEqual(deriveABUseCompressed, derivePaddedAB)).toBe(true);
+      expect(Buffer.compare(deriveABUseCompressed, derivePaddedAB)).toBe(0);
     });
   });
 });

test/derive.spec.ts

@@ -1,5 +1,4 @@
 /* eslint-disable import/no-extraneous-dependencies */
-import bufferEqual from "buffer-equal";
 import { beforeEach, describe, expect, it } from "vitest";
 
 import * as eccrypto from "../src/index";
@@ -39,18 +38,18 @@ describe("Functions: encrypt & decrypt", () => {
 
     it("should encrypt message when provided encryption options", async () => {
       const enc = await eccrypto.encrypt(publicKey, Buffer.from("test"), encOpts);
-      expect(bufferEqual(enc.iv, iv)).toBe(true);
-      expect(bufferEqual(enc.ephemPublicKey, ephemPublicKey)).toBe(true);
-      expect(bufferEqual(enc.ciphertext, ciphertext)).toBe(true);
-      expect(bufferEqual(enc.mac, mac)).toBe(true);
+      expect(Buffer.compare(enc.iv, iv)).toBe(0);
+      expect(Buffer.compare(enc.ephemPublicKey, ephemPublicKey)).toBe(0);
+      expect(Buffer.compare(enc.ciphertext, ciphertext)).toBe(0);
+      expect(Buffer.compare(enc.mac, mac)).toBe(0);
     });
 
     it("should encrypt with compressed public key", async () => {
       const enc = await eccrypto.encrypt(publicKeyCompressed, Buffer.from("test"), encOpts);
-      expect(bufferEqual(enc.iv, iv)).toBe(true);
-      expect(bufferEqual(enc.ephemPublicKey, ephemPublicKey)).toBe(true);
-      expect(bufferEqual(enc.ciphertext, ciphertext)).toBe(true);
-      expect(bufferEqual(enc.mac, mac)).toBe(true);
+      expect(Buffer.compare(enc.iv, iv)).toBe(0);
+      expect(Buffer.compare(enc.ephemPublicKey, ephemPublicKey)).toBe(0);
+      expect(Buffer.compare(enc.ciphertext, ciphertext)).toBe(0);
+      expect(Buffer.compare(enc.mac, mac)).toBe(0);
     });
 
     it("should throw 'Bad public key' on bad publicKey when encrypting", async () => {