@latticexyz/protocol-parser 2.0.0-snapshot-test-32d38619 → 2.0.0

package/src/decodeDynamicField.test.ts

@@ -22,28 +22,28 @@ describe("decodeDynamicField", () => {
 
   it("can decode uint256[]", () => {
     expect(
-      decodeDynamicField("uint256[]", "0x0000000000000000000000000000000000000000000000000000000000000000")
+      decodeDynamicField("uint256[]", "0x0000000000000000000000000000000000000000000000000000000000000000"),
     ).toStrictEqual([0n]);
     expect(
-      decodeDynamicField("uint256[]", "0x0000000000000000000000000000000000000000000000000000000000000001")
+      decodeDynamicField("uint256[]", "0x0000000000000000000000000000000000000000000000000000000000000001"),
     ).toStrictEqual([1n]);
     expect(
-      decodeDynamicField("uint256[]", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
+      decodeDynamicField("uint256[]", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
     ).toStrictEqual([115792089237316195423570985008687907853269984665640564039457584007913129639935n]);
     expect(
-      decodeDynamicField("uint256[]", "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe")
+      decodeDynamicField("uint256[]", "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"),
     ).toStrictEqual([115792089237316195423570985008687907853269984665640564039457584007913129639934n]);
     expect(
       decodeDynamicField(
         "uint256[]",
-        "0x00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001"
-      )
+        "0x00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001",
+      ),
     ).toStrictEqual([1n, 1n]);
     expect(
       decodeDynamicField(
         "uint256[]",
-        "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
-      )
+        "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+      ),
     ).toStrictEqual([
       115792089237316195423570985008687907853269984665640564039457584007913129639935n,
       115792089237316195423570985008687907853269984665640564039457584007913129639935n,
@@ -68,41 +68,41 @@ describe("decodeDynamicField", () => {
 
   it("can decode int256[]", () => {
     expect(
-      decodeDynamicField("int256[]", "0x0000000000000000000000000000000000000000000000000000000000000000")
+      decodeDynamicField("int256[]", "0x0000000000000000000000000000000000000000000000000000000000000000"),
     ).toStrictEqual([0n]);
     expect(
-      decodeDynamicField("int256[]", "0x0000000000000000000000000000000000000000000000000000000000000001")
+      decodeDynamicField("int256[]", "0x0000000000000000000000000000000000000000000000000000000000000001"),
     ).toStrictEqual([1n]);
     expect(
-      decodeDynamicField("int256[]", "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
+      decodeDynamicField("int256[]", "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
     ).toStrictEqual([57896044618658097711785492504343953926634992332820282019728792003956564819967n]);
     expect(
-      decodeDynamicField("int256[]", "0x8000000000000000000000000000000000000000000000000000000000000000")
+      decodeDynamicField("int256[]", "0x8000000000000000000000000000000000000000000000000000000000000000"),
     ).toStrictEqual([-57896044618658097711785492504343953926634992332820282019728792003956564819968n]);
     expect(
-      decodeDynamicField("int256[]", "0x8000000000000000000000000000000000000000000000000000000000000001")
+      decodeDynamicField("int256[]", "0x8000000000000000000000000000000000000000000000000000000000000001"),
     ).toStrictEqual([-57896044618658097711785492504343953926634992332820282019728792003956564819967n]);
     expect(
-      decodeDynamicField("int256[]", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
+      decodeDynamicField("int256[]", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
     ).toStrictEqual([-1n]);
 
     expect(
       decodeDynamicField(
         "int256[]",
-        "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
-      )
+        "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+      ),
     ).toStrictEqual([57896044618658097711785492504343953926634992332820282019728792003956564819967n, -1n]);
     expect(
       decodeDynamicField(
         "int256[]",
-        "0x80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
-      )
+        "0x80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+      ),
     ).toStrictEqual([-57896044618658097711785492504343953926634992332820282019728792003956564819968n, 0n]);
     expect(
       decodeDynamicField(
         "int256[]",
-        "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8000000000000000000000000000000000000000000000000000000000000001"
-      )
+        "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8000000000000000000000000000000000000000000000000000000000000001",
+      ),
     ).toStrictEqual([-1n, -57896044618658097711785492504343953926634992332820282019728792003956564819967n]);
   });
 
@@ -129,13 +129,13 @@ describe("decodeDynamicField", () => {
     ]);
     expect(decodeDynamicField("bytes4[]", "0xff00ff00ff00ff00")).toStrictEqual(["0xff00ff00", "0xff00ff00"]);
     expect(
-      decodeDynamicField("bytes32[]", "0x0000000000000000000000000000000000000000000000000000000000000001")
+      decodeDynamicField("bytes32[]", "0x0000000000000000000000000000000000000000000000000000000000000001"),
     ).toStrictEqual(["0x0000000000000000000000000000000000000000000000000000000000000001"]);
     expect(
       decodeDynamicField(
         "bytes32[]",
-        "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001"
-      )
+        "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001",
+      ),
     ).toStrictEqual([
       "0x0000000000000000000000000000000000000000000000000000000000000000",
       "0x0000000000000000000000000000000000000000000000000000000000000001",
@@ -151,10 +151,10 @@ describe("decodeDynamicField", () => {
     ]);
 
     expect(() => decodeDynamicField("address[]", "0x00")).toThrow(
-      'Hex value "0x00" has length of 2, but expected a multiple of 40 for address[] type.'
+      'Hex value "0x00" has length of 2, but expected a multiple of 40 for address[] type.',
     );
     expect(() => decodeDynamicField("address[]", "0xffffffffffffffffffffffffffffffffffffffffff")).toThrow(
-      'Hex value "0xffffffffffffffffffffffffffffffffffffffffff" has length of 42, but expected a multiple of 40 for address[] type.'
+      'Hex value "0xffffffffffffffffffffffffffffffffffffffffff" has length of 42, but expected a multiple of 40 for address[] type.',
     );
   });
 
@@ -164,7 +164,7 @@ describe("decodeDynamicField", () => {
     expect(decodeDynamicField("bytes", "0x0001")).toBe("0x0001");
     expect(decodeDynamicField("bytes", "0xff00ff00ff00ff00")).toBe("0xff00ff00ff00ff00");
     expect(decodeDynamicField("bytes", "0x0000000000000000000000000000000000000000000000000000000000000001")).toBe(
-      "0x0000000000000000000000000000000000000000000000000000000000000001"
+      "0x0000000000000000000000000000000000000000000000000000000000000001",
     );
   });
 

package/src/decodeDynamicField.ts

@@ -3,9 +3,9 @@ import { assertExhaustive } from "@latticexyz/common/utils";
 import {
   DynamicAbiType,
   DynamicAbiTypeToPrimitiveType,
-  arrayAbiTypeToStaticAbiType,
+  arrayToStaticAbiType,
   staticAbiTypeToByteLength,
-} from "@latticexyz/schema-type";
+} from "@latticexyz/schema-type/internal";
 import { decodeStaticField } from "./decodeStaticField";
 import { InvalidHexLengthError, InvalidHexLengthForArrayFieldError } from "./errors";
 
@@ -14,7 +14,7 @@ import { InvalidHexLengthError, InvalidHexLengthForArrayFieldError } from "./err
 
 export function decodeDynamicField<
   TAbiType extends DynamicAbiType,
-  TPrimitiveType extends DynamicAbiTypeToPrimitiveType<TAbiType>
+  TPrimitiveType extends DynamicAbiTypeToPrimitiveType<TAbiType>,
 >(abiType: TAbiType, data: Hex): TPrimitiveType {
   if (abiType === "bytes") {
     return data as TPrimitiveType;
@@ -128,7 +128,7 @@ export function decodeDynamicField<
     case "bytes32[]":
     case "bool[]":
     case "address[]": {
-      const staticAbiType = arrayAbiTypeToStaticAbiType(abiType);
+      const staticAbiType = arrayToStaticAbiType(abiType);
       const itemByteLength = staticAbiTypeToByteLength[staticAbiType];
       if (dataSize % itemByteLength !== 0) {
         throw new InvalidHexLengthForArrayFieldError(staticAbiType, data);

package/src/decodeField.ts

@@ -1,11 +1,11 @@
 import { Hex } from "viem";
-import { SchemaAbiType, SchemaAbiTypeToPrimitiveType, isDynamicAbiType } from "@latticexyz/schema-type";
+import { SchemaAbiType, SchemaAbiTypeToPrimitiveType, isDynamicAbiType } from "@latticexyz/schema-type/internal";
 import { decodeDynamicField } from "./decodeDynamicField";
 import { decodeStaticField } from "./decodeStaticField";
 
 export function decodeField<
   TAbiType extends SchemaAbiType,
-  TPrimitiveType extends SchemaAbiTypeToPrimitiveType<TAbiType>
+  TPrimitiveType extends SchemaAbiTypeToPrimitiveType<TAbiType>,
 >(abiType: TAbiType, data: Hex): TPrimitiveType {
   return (
     isDynamicAbiType(abiType) ? decodeDynamicField(abiType, data) : decodeStaticField(abiType, data)

package/src/decodeKey.ts

@@ -4,12 +4,12 @@ import { decodeKeyTuple } from "./decodeKeyTuple";
 
 export function decodeKey<TSchema extends KeySchema>(
   keySchema: TSchema,
-  data: readonly Hex[]
+  data: readonly Hex[],
 ): SchemaToPrimitives<TSchema> {
   // TODO: refactor and move all decodeKeyTuple logic into this method so we can delete decodeKeyTuple
   const keyValues = decodeKeyTuple({ staticFields: Object.values(keySchema), dynamicFields: [] }, data);
 
   return Object.fromEntries(
-    Object.keys(keySchema).map((name, i) => [name, keyValues[i]])
+    Object.keys(keySchema).map((name, i) => [name, keyValues[i]]),
   ) as SchemaToPrimitives<TSchema>;
 }

package/src/decodeKeyTuple.test.ts

@@ -6,12 +6,12 @@ describe("decodeKeyTuple", () => {
     expect(
       decodeKeyTuple({ staticFields: ["bool"], dynamicFields: [] }, [
         "0x0000000000000000000000000000000000000000000000000000000000000000",
-      ])
+      ]),
     ).toStrictEqual([false]);
     expect(
       decodeKeyTuple({ staticFields: ["bool"], dynamicFields: [] }, [
         "0x0000000000000000000000000000000000000000000000000000000000000001",
-      ])
+      ]),
     ).toStrictEqual([true]);
   });
 
@@ -24,7 +24,7 @@ describe("decodeKeyTuple", () => {
         "0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff",
         "0x0000000000000000000000000000000000000000000000000000000000000001",
         "0x0000000000000000000000000000000000000000000000000000000000000003",
-      ])
+      ]),
     ).toStrictEqual([
       42n,
       -42,

package/src/decodeKeyTuple.ts

@@ -1,5 +1,5 @@
 import { Hex, decodeAbiParameters } from "viem";
-import { StaticPrimitiveType } from "@latticexyz/schema-type";
+import { StaticPrimitiveType } from "@latticexyz/schema-type/internal";
 import { Schema } from "./common";
 
 // key tuples are encoded in the same way as abi.encode, so we can decode them with viem
@@ -8,10 +8,10 @@ import { Schema } from "./common";
 export function decodeKeyTuple(keySchema: Schema, keyTuple: readonly Hex[]): StaticPrimitiveType[] {
   if (keySchema.staticFields.length !== keyTuple.length) {
     throw new Error(
-      `key tuple length ${keyTuple.length} does not match key schema length ${keySchema.staticFields.length}`
+      `key tuple length ${keyTuple.length} does not match key schema length ${keySchema.staticFields.length}`,
     );
   }
   return keyTuple.map(
-    (key, index) => decodeAbiParameters([{ type: keySchema.staticFields[index] }], key)[0] as StaticPrimitiveType
+    (key, index) => decodeAbiParameters([{ type: keySchema.staticFields[index] }], key)[0] as StaticPrimitiveType,
   );
 }

package/src/decodeRecord.test.ts

@@ -6,7 +6,7 @@ describe("decodeRecord", () => {
     const valueSchema = { staticFields: ["uint32", "uint128"], dynamicFields: ["uint32[]", "string"] } as const;
     const values = decodeRecord(
       valueSchema,
-      "0x0000000100000000000000000000000000000002000000000000000000000000000000000000000b0000000008000000000000130000000300000004736f6d6520737472696e67"
+      "0x0000000100000000000000000000000000000002000000000000000000000000000000000000000b0000000008000000000000130000000300000004736f6d6520737472696e67",
     );
     expect(values).toStrictEqual([1, 2n, [3, 4], "some string"]);
   });

package/src/decodeRecord.ts

@@ -3,12 +3,12 @@ import {
   DynamicPrimitiveType,
   staticAbiTypeToByteLength,
   dynamicAbiTypeToDefaultValue,
-} from "@latticexyz/schema-type";
+} from "@latticexyz/schema-type/internal";
 import { Hex } from "viem";
 import { Schema } from "./common";
 import { decodeDynamicField } from "./decodeDynamicField";
 import { decodeStaticField } from "./decodeStaticField";
-import { hexToPackedCounter } from "./hexToPackedCounter";
+import { hexToEncodedLengths } from "./hexToEncodedLengths";
 import { staticDataLength } from "./staticDataLength";
 import { readHex } from "@latticexyz/common";
 
@@ -34,12 +34,12 @@ export function decodeRecord(valueSchema: Schema, data: Hex): readonly (StaticPr
         expectedLength: schemaStaticDataLength,
         actualLength: actualStaticDataLength,
         bytesOffset,
-      }
+      },
     );
   }
 
   if (valueSchema.dynamicFields.length > 0) {
-    const dataLayout = hexToPackedCounter(readHex(data, bytesOffset, bytesOffset + 32));
+    const dataLayout = hexToEncodedLengths(readHex(data, bytesOffset, bytesOffset + 32));
     bytesOffset += 32;
 
     valueSchema.dynamicFields.forEach((fieldType, i) => {
@@ -63,7 +63,7 @@ export function decodeRecord(valueSchema: Schema, data: Hex): readonly (StaticPr
           expectedLength: dataLayout.totalByteLength,
           actualLength: actualDynamicDataLength,
           bytesOffset,
-        }
+        },
       );
     }
   }

package/src/decodeStaticField.test.ts

@@ -7,22 +7,22 @@ describe("decodeStaticField", () => {
     expect(decodeStaticField("bool", "0x01")).toBe(true);
 
     expect(() => decodeStaticField("bool", "0x0")).toThrow(
-      'Hex value "0x0" has length of 1, but expected length of 2 for bool type.'
+      'Hex value "0x0" has length of 1, but expected length of 2 for bool type.',
     );
     expect(() => decodeStaticField("bool", "0x1")).toThrow(
-      'Hex value "0x1" has length of 1, but expected length of 2 for bool type.'
+      'Hex value "0x1" has length of 1, but expected length of 2 for bool type.',
     );
     expect(() => decodeStaticField("bool", "0x000")).toThrow(
-      'Hex value "0x000" is an odd length (3). It must be an even length.'
+      'Hex value "0x000" is an odd length (3). It must be an even length.',
     );
     expect(() => decodeStaticField("bool", "0x001")).toThrow(
-      'Hex value "0x001" is an odd length (3). It must be an even length.'
+      'Hex value "0x001" is an odd length (3). It must be an even length.',
     );
     expect(() => decodeStaticField("bool", "0x0000")).toThrow(
-      'Hex value "0x0000" has length of 4, but expected length of 2 for bool type.'
+      'Hex value "0x0000" has length of 4, but expected length of 2 for bool type.',
     );
     expect(() => decodeStaticField("bool", "0x0001")).toThrow(
-      'Hex value "0x0001" has length of 4, but expected length of 2 for bool type.'
+      'Hex value "0x0001" has length of 4, but expected length of 2 for bool type.',
     );
   });
 
@@ -36,10 +36,10 @@ describe("decodeStaticField", () => {
     expect(decodeStaticField("uint256", "0x0000000000000000000000000000000000000000000000000000000000000000")).toBe(0n);
     expect(decodeStaticField("uint256", "0x0000000000000000000000000000000000000000000000000000000000000001")).toBe(1n);
     expect(decodeStaticField("uint256", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")).toBe(
-      115792089237316195423570985008687907853269984665640564039457584007913129639935n
+      115792089237316195423570985008687907853269984665640564039457584007913129639935n,
     );
     expect(decodeStaticField("uint256", "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe")).toBe(
-      115792089237316195423570985008687907853269984665640564039457584007913129639934n
+      115792089237316195423570985008687907853269984665640564039457584007913129639934n,
     );
   });
 
@@ -56,13 +56,13 @@ describe("decodeStaticField", () => {
     expect(decodeStaticField("int256", "0x0000000000000000000000000000000000000000000000000000000000000000")).toBe(0n);
     expect(decodeStaticField("int256", "0x0000000000000000000000000000000000000000000000000000000000000001")).toBe(1n);
     expect(decodeStaticField("int256", "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")).toBe(
-      57896044618658097711785492504343953926634992332820282019728792003956564819967n
+      57896044618658097711785492504343953926634992332820282019728792003956564819967n,
     );
     expect(decodeStaticField("int256", "0x8000000000000000000000000000000000000000000000000000000000000000")).toBe(
-      -57896044618658097711785492504343953926634992332820282019728792003956564819968n
+      -57896044618658097711785492504343953926634992332820282019728792003956564819968n,
     );
     expect(decodeStaticField("int256", "0x8000000000000000000000000000000000000000000000000000000000000001")).toBe(
-      -57896044618658097711785492504343953926634992332820282019728792003956564819967n
+      -57896044618658097711785492504343953926634992332820282019728792003956564819967n,
     );
     expect(decodeStaticField("int256", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")).toBe(-1n);
   });
@@ -72,23 +72,23 @@ describe("decodeStaticField", () => {
     expect(decodeStaticField("bytes2", "0x0001")).toBe("0x0001");
     expect(decodeStaticField("bytes8", "0xff00ff00ff00ff00")).toBe("0xff00ff00ff00ff00");
     expect(decodeStaticField("bytes32", "0x0000000000000000000000000000000000000000000000000000000000000001")).toBe(
-      "0x0000000000000000000000000000000000000000000000000000000000000001"
+      "0x0000000000000000000000000000000000000000000000000000000000000001",
     );
   });
 
   it("can decode address", () => {
     expect(decodeStaticField("address", "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266")).toBe(
-      "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"
+      "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
     );
     expect(decodeStaticField("address", "0xffffffffffffffffffffffffffffffffffffffff")).toBe(
-      "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF"
+      "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF",
     );
 
     expect(() => decodeStaticField("address", "0x00")).toThrow(
-      'Hex value "0x00" has length of 2, but expected length of 40 for address type.'
+      'Hex value "0x00" has length of 2, but expected length of 40 for address type.',
     );
     expect(() => decodeStaticField("address", "0xffffffffffffffffffffffffffffffffffffffffff")).toThrow(
-      'Hex value "0xffffffffffffffffffffffffffffffffffffffffff" has length of 42, but expected length of 40 for address type.'
+      'Hex value "0xffffffffffffffffffffffffffffffffffffffffff" has length of 42, but expected length of 40 for address type.',
     );
   });
 });

package/src/decodeStaticField.ts

@@ -5,12 +5,12 @@ import {
   StaticAbiTypeToPrimitiveType,
   staticAbiTypeToByteLength,
   staticAbiTypeToDefaultValue,
-} from "@latticexyz/schema-type";
+} from "@latticexyz/schema-type/internal";
 import { InvalidHexLengthError, InvalidHexLengthForStaticFieldError } from "./errors";
 
 export function decodeStaticField<
   TAbiType extends StaticAbiType,
-  TPrimitiveType extends StaticAbiTypeToPrimitiveType<TAbiType>
+  TPrimitiveType extends StaticAbiTypeToPrimitiveType<TAbiType>,
 >(abiType: TAbiType, data: Hex): TPrimitiveType {
   if (data.length > 3 && data.length % 2 !== 0) {
     throw new InvalidHexLengthError(data);

package/src/decodeValue.ts

@@ -1,4 +1,4 @@
-import { isStaticAbiType, isDynamicAbiType } from "@latticexyz/schema-type";
+import { isStaticAbiType, isDynamicAbiType } from "@latticexyz/schema-type/internal";
 import { Hex } from "viem";
 import { SchemaToPrimitives, ValueSchema } from "./common";
 import { decodeRecord } from "./decodeRecord";
@@ -11,6 +11,6 @@ export function decodeValue<TSchema extends ValueSchema>(valueSchema: TSchema, d
   const valueTuple = decodeRecord({ staticFields, dynamicFields }, data);
 
   return Object.fromEntries(
-    Object.keys(valueSchema).map((name, i) => [name, valueTuple[i]])
+    Object.keys(valueSchema).map((name, i) => [name, valueTuple[i]]),
   ) as SchemaToPrimitives<TSchema>;
 }

package/src/decodeValueArgs.ts

@@ -1,5 +1,5 @@
 import { concatHex } from "viem";
-import { isStaticAbiType } from "@latticexyz/schema-type";
+import { isStaticAbiType } from "@latticexyz/schema-type/internal";
 import { SchemaToPrimitives, ValueArgs, ValueSchema } from "./common";
 import { decodeValue } from "./decodeValue";
 import { staticDataLength } from "./staticDataLength";
@@ -7,7 +7,7 @@ import { readHex } from "@latticexyz/common";
 
 export function decodeValueArgs<TSchema extends ValueSchema>(
   valueSchema: TSchema,
-  { staticData, encodedLengths, dynamicData }: ValueArgs
+  { staticData, encodedLengths, dynamicData }: ValueArgs,
 ): SchemaToPrimitives<TSchema> {
   return decodeValue(
     valueSchema,
@@ -15,6 +15,6 @@ export function decodeValueArgs<TSchema extends ValueSchema>(
       readHex(staticData, 0, staticDataLength(Object.values(valueSchema).filter(isStaticAbiType))),
       encodedLengths,
       dynamicData,
-    ])
+    ]),
   );
 }

package/src/encodeField.ts

@@ -1,19 +1,19 @@
-import { SchemaAbiType, arrayAbiTypeToStaticAbiType, isArrayAbiType } from "@latticexyz/schema-type";
+import { SchemaAbiType, arrayToStaticAbiType, isArrayAbiType } from "@latticexyz/schema-type/internal";
 import { AbiParameterToPrimitiveType } from "abitype";
 import { Hex, encodePacked } from "viem";
 
 export function encodeField<TSchemaAbiType extends SchemaAbiType>(
   fieldType: TSchemaAbiType,
-  value: AbiParameterToPrimitiveType<{ type: TSchemaAbiType }>
+  value: AbiParameterToPrimitiveType<{ type: TSchemaAbiType }>,
 ): Hex {
   if (isArrayAbiType(fieldType) && Array.isArray(value)) {
-    const staticFieldType = arrayAbiTypeToStaticAbiType(fieldType);
+    const staticFieldType = arrayToStaticAbiType(fieldType);
     // TODO: we can remove conditional once this is fixed: https://github.com/wagmi-dev/viem/pull/1147
     return value.length === 0
       ? "0x"
       : encodePacked(
           value.map(() => staticFieldType),
-          value
+          value,
         );
   }
   return encodePacked([fieldType], [value]);

package/src/encodeKey.ts

@@ -1,4 +1,4 @@
-import { isStaticAbiType } from "@latticexyz/schema-type";
+import { isStaticAbiType } from "@latticexyz/schema-type/internal";
 import { Hex } from "viem";
 import { SchemaToPrimitives, KeySchema } from "./common";
 import { encodeKeyTuple } from "./encodeKeyTuple";

package/src/encodeKeyTuple.test.ts

@@ -12,8 +12,8 @@ describe("encodeKeyTuple", () => {
           staticFields: ["bool"],
           dynamicFields: [],
         },
-        [true]
-      )
+        [true],
+      ),
     ).toStrictEqual(["0x0000000000000000000000000000000000000000000000000000000000000001"]);
   });
 
@@ -26,7 +26,7 @@ describe("encodeKeyTuple", () => {
         "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF",
         true,
         3,
-      ])
+      ]),
     ).toStrictEqual([
       "0x000000000000000000000000000000000000000000000000000000000000002a",
       "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd6",

package/src/encodeKeyTuple.ts

@@ -1,4 +1,4 @@
-import { StaticPrimitiveType } from "@latticexyz/schema-type";
+import { StaticPrimitiveType } from "@latticexyz/schema-type/internal";
 import { Hex, encodeAbiParameters } from "viem";
 import { Schema } from "./common";
 

package/src/encodeLengths.test.ts

@@ -2,9 +2,15 @@ import { describe, expect, it } from "vitest";
 import { encodeLengths } from "./encodeLengths";
 
 describe("encodeLengths", () => {
+  it("can encode empty tuple", () => {
+    expect(encodeLengths([])).toMatchInlineSnapshot(
+      '"0x0000000000000000000000000000000000000000000000000000000000000000"',
+    );
+  });
+
   it("can encode bool key tuple", () => {
     expect(encodeLengths(["0x1234", "0x12345678"])).toMatchInlineSnapshot(
-      '"0x0000000000000000000000000000000000000004000000000200000000000006"'
+      '"0x0000000000000000000000000000000000000004000000000200000000000006"',
     );
   });
 });

package/src/encodeLengths.ts

@@ -7,6 +7,6 @@ export function encodeLengths(values: Hex[]): Hex {
 
   return padHex(
     concatHex([...byteLengths.map((length) => encodeField("uint40", length)), encodeField("uint56", totalByteLength)]),
-    { size: 32, dir: "left" }
+    { size: 32, dir: "left" },
   );
 }

package/src/encodeRecord.test.ts

@@ -6,7 +6,7 @@ describe("encodeRecord", () => {
     const valueSchema = { staticFields: ["uint32", "uint128"], dynamicFields: ["uint32[]", "string"] } as const;
     const hex = encodeRecord(valueSchema, [1, 2n, [3, 4], "some string"]);
     expect(hex).toBe(
-      "0x0000000100000000000000000000000000000002000000000000000000000000000000000000000b0000000008000000000000130000000300000004736f6d6520737472696e67"
+      "0x0000000100000000000000000000000000000002000000000000000000000000000000000000000b0000000008000000000000130000000300000004736f6d6520737472696e67",
     );
   });
 

package/src/encodeRecord.ts

@@ -1,4 +1,4 @@
-import { StaticPrimitiveType, DynamicPrimitiveType } from "@latticexyz/schema-type";
+import { StaticPrimitiveType, DynamicPrimitiveType } from "@latticexyz/schema-type/internal";
 import { Hex } from "viem";
 import { encodeField } from "./encodeField";
 import { Schema } from "./common";
@@ -6,7 +6,7 @@ import { Schema } from "./common";
 /** @deprecated use `encodeValue` instead */
 export function encodeRecord(
   valueSchema: Schema,
-  values: readonly (StaticPrimitiveType | DynamicPrimitiveType)[]
+  values: readonly (StaticPrimitiveType | DynamicPrimitiveType)[],
 ): Hex {
   const staticValues = values.slice(0, valueSchema.staticFields.length) as readonly StaticPrimitiveType[];
   const dynamicValues = values.slice(valueSchema.staticFields.length) as readonly DynamicPrimitiveType[];
@@ -18,7 +18,7 @@ export function encodeRecord(
   if (valueSchema.dynamicFields.length === 0) return `0x${staticData}`;
 
   const dynamicDataItems = dynamicValues.map((value, i) =>
-    encodeField(valueSchema.dynamicFields[i], value).replace(/^0x/, "")
+    encodeField(valueSchema.dynamicFields[i], value).replace(/^0x/, ""),
   );
 
   const dynamicFieldByteLengths = dynamicDataItems.map((value) => value.length / 2).reverse();
@@ -26,9 +26,9 @@ export function encodeRecord(
 
   const dynamicData = dynamicDataItems.join("");
 
-  const packedCounter = `${dynamicFieldByteLengths
+  const encodedLengths = `${dynamicFieldByteLengths
     .map((length) => encodeField("uint40", length).replace(/^0x/, ""))
     .join("")}${encodeField("uint56", dynamicTotalByteLength).replace(/^0x/, "")}`.padStart(64, "0");
 
-  return `0x${staticData}${packedCounter}${dynamicData}`;
+  return `0x${staticData}${encodedLengths}${dynamicData}`;
 }

package/src/encodeValue.ts

@@ -4,7 +4,7 @@ import { encodeValueArgs } from "./encodeValueArgs";
 
 export function encodeValue<TSchema extends ValueSchema>(
   valueSchema: TSchema,
-  value: SchemaToPrimitives<TSchema>
+  value: SchemaToPrimitives<TSchema>,
 ): Hex {
   const { staticData, encodedLengths, dynamicData } = encodeValueArgs(valueSchema, value);
   return concatHex([staticData, encodedLengths, dynamicData]);

package/src/encodeValueArgs.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from "vitest";
+import { encodeValueArgs } from "./encodeValueArgs";
+import { stringToHex } from "viem";
+
+describe("encodeValueArgs", () => {
+  it("can encode record value to hex", () => {
+    const valueSchema = {
+      entityId: "bytes32",
+      exists: "bool",
+      playerName: "string",
+      badges: "uint256[]",
+    } as const;
+
+    const result = encodeValueArgs(valueSchema, {
+      entityId: stringToHex("hello", { size: 32 }),
+      exists: true,
+      playerName: "henry",
+      badges: [42n],
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "dynamicData": "0x68656e7279000000000000000000000000000000000000000000000000000000000000002a",
+        "encodedLengths": "0x0000000000000000000000000000000000000020000000000500000000000025",
+        "staticData": "0x68656c6c6f00000000000000000000000000000000000000000000000000000001",
+      }
+    `);
+  });
+
+  it("encodes record when key order of value and valueSchema do not match", () => {
+    const valueSchema = {
+      entityId: "bytes32",
+      playerName: "string",
+      exists: "bool",
+      badges: "uint256[]",
+    } as const;
+
+    const result = encodeValueArgs(valueSchema, {
+      exists: true,
+      playerName: "henry",
+      entityId: stringToHex("hello", { size: 32 }),
+      badges: [42n],
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "dynamicData": "0x68656e7279000000000000000000000000000000000000000000000000000000000000002a",
+        "encodedLengths": "0x0000000000000000000000000000000000000020000000000500000000000025",
+        "staticData": "0x68656c6c6f00000000000000000000000000000000000000000000000000000001",
+      }
+    `);
+  });
+});