fix three bugs in discriminate and clean up (#567)

Author: nonergodic

core/base/__tests__/layout.ts

@@ -2,11 +2,8 @@ import { describe, expect, it } from "@jest/globals";
 
 import {
   Layout,
-  LayoutToType,
-  RoArray,
   addFixedValues,
   bitsetItem,
-  column,
   deserializeLayout,
   layoutDiscriminator,
   serializeLayout,
@@ -383,63 +380,32 @@ describe("Layout tests", function () {
       expect(discriminator(Uint8Array.from([0, 0]))).toEqual([2]);
     });
 
-  });
-});
-
-describe("Switch Layout Size Tests", () => {
-  it("Can discriminate a set of layouts", () => {
-    const layouta = [
-      {
-        name: "payload",
-        binary: "bytes",
-        lengthSize: 2,
-        layout: [
-          {
-            name: "payload",
-            binary: "switch",
-            idSize: 1,
-            layouts: [
-              [[0, "Direct"], []],
-              [[1, "Payload"], [{ name: "data", binary: "bytes", lengthSize: 4 }]],
-            ],
-          },
+    it("can discriminate a switch layout with the same byte value in all cases", () => {
+      const switchLayout = {
+        binary: "switch",
+        idSize: 1,
+        layouts: [
+          [[0, "first"], [
+            {name: "fixed1", binary: "uint", size: 1, custom: 32 },
+            {name: "variable1", binary: "bytes", lengthSize: 1 },
+          ]],
+          [[1, "second"], [
+            {name: "fixed2", binary: "uint", size: 1, custom: 32 },
+            {name: "variable2", binary: "bytes", lengthSize: 2 },
+          ]],
         ],
-      },
-    ] as const satisfies Layout;
+      } as const satisfies Layout;
 
-    const layoutb = [
-      {
-        name: "payload",
+      const secondByteLayout = {
         binary: "bytes",
-        lengthSize: 3,
-        layout: [
-          {
-            name: "payload",
-            binary: "switch",
-            idSize: 1,
-            layouts: [
-              [[0, "Nothing"], []],
-              [[1, "Data"], [{ name: "data", binary: "bytes", lengthSize: 4 }]],
-            ],
-          },
-        ],
-      },
-    ] as const satisfies Layout;
+        custom: new Uint8Array([1, 33, 0]),
+      } as const satisfies Layout;
 
-    const messageLayouts = [
-      ["Layout", layouta],
-      ["LayoutB", layoutb],
-    ] as const satisfies RoArray<[string, Layout]>;
-    const messageDiscriminator = layoutDiscriminator(column(messageLayouts, 1));
+      const messageDiscriminator = layoutDiscriminator([switchLayout, secondByteLayout]);
 
-    const b: LayoutToType<typeof layoutb> = {
-      payload: {
-        payload: { id: "Data", data: new Uint8Array([0, 0, 0, 0]) },
-      },
-    };
-
-    const data = serializeLayout(layoutb, b);
-    const idx = messageDiscriminator(data);
-    expect(idx).toEqual(1);
+      expect(messageDiscriminator(new Uint8Array([0, 32, 1, 128]))).toEqual(0);
+      expect(messageDiscriminator(new Uint8Array([0, 33, 0]))).toEqual(1);
+      expect(messageDiscriminator(new Uint8Array([0, 34, 0]))).toEqual(null);
+    });
   });
 });

core/base/src/utils/layout/discriminate.ts

@@ -39,7 +39,7 @@ function count(candidates: Candidates) {
 }
 
 const lengthSizeMax = (lengthSize: number) =>
-  lengthSize > 0 ? (1 << (8 * lengthSize)) - 1 : Infinity;
+  lengthSize > 0 ? 2**(8 * lengthSize) - 1 : Infinity;
 
 function layoutItemMeta(
   item: LayoutItem,
@@ -157,13 +157,13 @@ function layoutItemMeta(
           serializeNum(idVal, idSize, cursor, idEndianness);
           caseFixedBytes[caseIndex]!.push([0, cursor.bytes]);
         }
-        const ret = createLayoutMeta(layout, offset ? idSize : null, caseFixedBytes[caseIndex]!);
+        const ret = createLayoutMeta(layout, offset !== null ? idSize : null, caseFixedBytes[caseIndex]!);
         return [ret[0] + idSize, ret[1] + idSize] as Bounds;
       });
 
-      if (offset !== null)
-        //find bytes that have the same value across all cases (turning this into a lambda to enable
-        //  early return from inner loops)
+      if (offset !== null && caseFixedBytes.every(fbs => fbs.length > 0))
+        //find bytes that have the same value across all cases
+        //  (it's a lambda to enable early return from inner loops)
         (() => {
           //constrain search to the minimum length of all cases
           const minLen = Math.min(
@@ -172,34 +172,36 @@ function layoutItemMeta(
           //keep track of the current index in each case's fixed bytes array
           const itIndexes = caseFixedBytes.map(_ => 0);
 
-          let caseIndex = 0;
           for (let bytePos = 0; bytePos < minLen;) {
             let byteVal = null;
+            let caseIndex = 0;
             while (caseIndex < caseFixedBytes.length) {
-              let curItIndex = itIndexes[caseIndex];
-              const curFixedBytes = caseFixedBytes[caseIndex];
-              const [curOffset, curSerialized] = curFixedBytes![curItIndex!]!;
+              let curItIndex = itIndexes[caseIndex]!;
+              const curFixedBytes = caseFixedBytes[caseIndex]!;
+              const [curOffset, curSerialized] = curFixedBytes[curItIndex]!;
               if (curOffset + curSerialized.length <= bytePos) {
                 //no fixed byte at this position in this case
-                ++curItIndex!;
+                ++curItIndex;
 
-                if (curItIndex === curFixedBytes!.length)
+                if (curItIndex === curFixedBytes.length)
                   return; //we have exhausted all fixed bytes in at least one case
 
-                itIndexes[caseIndex] = curItIndex!;
+                itIndexes[caseIndex] = curItIndex;
                 //jump to the next possible bytePos given the fixed bytes of the current case index
-                bytePos = curFixedBytes![curItIndex!]![0];
+                bytePos = curFixedBytes[curItIndex]![0];
                 break;
               }
 
               const curByteVal = curSerialized[bytePos - curOffset];
               if (byteVal === null)
                 byteVal = curByteVal;
 
-              if (curByteVal !== byteVal)
+              if (curByteVal !== byteVal) {
+                ++bytePos;
                 break;
+              }
 
-              caseIndex++;
+              ++caseIndex;
             }
 
             //only if we made it through all cases without breaking do we have a fixed byte