fix: chunkIntoN to chunk correctly (#6035)

* fix: fixed chunkIntoN to chunk correctly (#6018)

* FIX: fixed chunkIntoN to chunk correctly

chunkIntoN was chunking into N chunks, however it is used to chunk eth_getCode and eth_getProof responses into chunks of 2, so the desired action should be to chunk into chunks of length N
https://github.com/ChainSafe/lodestar/blob/unstable/packages/prover/src/utils/evm.ts#L105

Because the current tests work on chunking array of length 4 into 2 the previous behavior was working and passing tests. When there are 6 requests the current behavior no longer works

* Fix strings in test

* Add more test cases

* Update test title

* Update packages/prover/test/unit/utils/conversion.test.ts

Co-authored-by: Nico Flaig <nflaig@protonmail.com>

* Update the test description

* Update the test description

* Update the test description

---------

Co-authored-by: Roman Dvorkin <121502696+rdvorkin@users.noreply.github.com>
Co-authored-by: Nico Flaig <nflaig@protonmail.com>

packages/prover/src/utils/conversion.ts

@@ -97,12 +97,11 @@ export function cleanObject<T extends Record<string, unknown> | unknown[]>(obj:
 }
 
 /**
- * Convert an array to array of chunks
+ * Convert an array to array of chunks of length N
  * @example
- * chunkIntoN([1,2,3,4], 2)
- * => [[1,2], [3,4]]
+ * chunkIntoN([1,2,3,4,5,6], 2)
+ * => [[1,2], [3,4], [5,6]]
  */
 export function chunkIntoN<T extends unknown[]>(arr: T, n: number): T[] {
-  const size = Math.ceil(arr.length / n);
-  return Array.from({length: n}, (v, i) => arr.slice(i * size, i * size + size)) as T[];
+  return Array.from({length: Math.ceil(arr.length / n)}, (_, i) => arr.slice(i * n, i * n + n)) as T[];
 }

packages/prover/test/unit/utils/conversion.test.ts

@@ -0,0 +1,86 @@
+import {expect} from "chai";
+import {chunkIntoN} from "../../../src/utils/conversion.js";
+
+describe("utils/conversion", () => {
+  describe("chunkIntoN", () => {
+    const testCases = [
+      {
+        title: "even number of chunks",
+        input: {
+          data: [1, 2, 3, 4, 5, 6],
+          n: 2,
+        },
+        output: [
+          [1, 2],
+          [3, 4],
+          [5, 6],
+        ],
+      },
+      {
+        title: "even number of chunks with additional element",
+        input: {
+          data: [1, 2, 3, 4, 5, 6, 7],
+          n: 2,
+        },
+        output: [[1, 2], [3, 4], [5, 6], [7]],
+      },
+      {
+        title: "odd number of chunks",
+        input: {
+          data: [1, 2, 3, 4, 5, 6],
+          n: 3,
+        },
+        output: [
+          [1, 2, 3],
+          [4, 5, 6],
+        ],
+      },
+      {
+        title: "odd number of chunks with additional element",
+        input: {
+          data: [1, 2, 3, 4, 5, 6, 7],
+          n: 3,
+        },
+        output: [[1, 2, 3], [4, 5, 6], [7]],
+      },
+      {
+        title: "data less than chunk size",
+        input: {
+          data: [1],
+          n: 3,
+        },
+        output: [[1]],
+      },
+      {
+        title: "data 1 less than chunk size",
+        input: {
+          data: [1, 2],
+          n: 3,
+        },
+        output: [[1, 2]],
+      },
+      {
+        title: "data 1 extra than chunk size",
+        input: {
+          data: [1, 2, 3, 4],
+          n: 3,
+        },
+        output: [[1, 2, 3], [4]],
+      },
+    ];
+
+    for (const {title, input, output} of testCases) {
+      it(`should chunkify data when ${title}`, async () => {
+        expect(chunkIntoN(input.data, input.n)).to.be.deep.eq(output);
+      });
+    }
+
+    it("should not change the order of elements", () => {
+      expect(chunkIntoN([6, 5, 4, 3, 2, 1], 2)).to.be.deep.eq([
+        [6, 5],
+        [4, 3],
+        [2, 1],
+      ]);
+    });
+  });
+});