@latticexyz/protocol-parser 2.0.12-main-d7526607 → 2.0.12-main-96e7bf43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@latticexyz/protocol-parser",
-  "version": "2.0.12-main-d7526607",
+  "version": "2.0.12-main-96e7bf43",
   "description": "Parser utilities for the MUD protocol",
   "repository": {
     "type": "git",
@@ -13,22 +13,15 @@
     ".": "./dist/index.js",
     "./internal": "./dist/internal.js"
   },
-  "typesVersions": {
-    "*": {
-      "index": [
-        "./src/exports/index.ts"
-      ],
-      "internal": [
-        "./src/exports/internal.ts"
-      ]
-    }
-  },
+  "files": [
+    "dist"
+  ],
   "dependencies": {
     "abitype": "1.0.0",
     "viem": "2.9.20",
-    "@latticexyz/common": "2.0.12-main-d7526607",
-    "@latticexyz/config": "2.0.12-main-d7526607",
-    "@latticexyz/schema-type": "2.0.12-main-d7526607"
+    "@latticexyz/common": "2.0.12-main-96e7bf43",
+    "@latticexyz/config": "2.0.12-main-96e7bf43",
+    "@latticexyz/schema-type": "2.0.12-main-96e7bf43"
   },
   "devDependencies": {
     "tsup": "^6.7.0",

package/src/abiTypesToSchema.test.ts

@@ -1,39 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { abiTypesToSchema } from "./abiTypesToSchema";
-
-describe("hexToSchema", () => {
-  it("converts hex to schema", () => {
-    expect(abiTypesToSchema(["bool"])).toMatchInlineSnapshot(`
-      {
-        "dynamicFields": [],
-        "staticFields": [
-          "bool",
-        ],
-      }
-    `);
-    expect(abiTypesToSchema(["bool", "bool[]"])).toMatchInlineSnapshot(`
-      {
-        "dynamicFields": [
-          "bool[]",
-        ],
-        "staticFields": [
-          "bool",
-        ],
-      }
-    `);
-    expect(abiTypesToSchema(["bytes32", "int32", "uint256[]", "address[]", "bytes", "string"])).toMatchInlineSnapshot(`
-      {
-        "dynamicFields": [
-          "uint256[]",
-          "address[]",
-          "bytes",
-          "string",
-        ],
-        "staticFields": [
-          "bytes32",
-          "int32",
-        ],
-      }
-    `);
-  });
-});

package/src/abiTypesToSchema.ts

@@ -1,12 +0,0 @@
-import { DynamicAbiType, SchemaAbiType, StaticAbiType, isDynamicAbiType } from "@latticexyz/schema-type/internal";
-import { Schema } from "./common";
-
-export function abiTypesToSchema(abiTypes: SchemaAbiType[]): Schema {
-  const staticFields: StaticAbiType[] = [];
-  const dynamicFields: DynamicAbiType[] = [];
-  for (const abiType of abiTypes) {
-    if (isDynamicAbiType(abiType)) dynamicFields.push(abiType);
-    else staticFields.push(abiType);
-  }
-  return { staticFields, dynamicFields };
-}

package/src/common.ts

@@ -1,52 +0,0 @@
-import {
-  DynamicAbiType,
-  SchemaAbiType,
-  SchemaAbiTypeToPrimitiveType,
-  StaticAbiType,
-} from "@latticexyz/schema-type/internal";
-import { Hex } from "viem";
-
-/** @deprecated use `KeySchema` or `ValueSchema` instead */
-export type Schema = {
-  readonly staticFields: readonly StaticAbiType[];
-  readonly dynamicFields: readonly DynamicAbiType[];
-};
-
-/** @deprecated use `KeySchema` and `ValueSchema` instead */
-export type TableSchema = {
-  readonly keySchema: Schema; // TODO: refine to set dynamicFields to []
-  readonly valueSchema: Schema;
-};
-
-export type FieldLayout = {
-  readonly staticFieldLengths: readonly number[];
-  readonly numDynamicFields: number;
-};
-
-// TODO: helper to filter user types to StaticAbiType
-export type UserTypes = Record<string, { internalType: SchemaAbiType }>;
-
-export type KeySchema<userTypes extends UserTypes | undefined = undefined> = Record<
-  string,
-  userTypes extends UserTypes ? StaticAbiType | keyof userTypes : StaticAbiType
->;
-export type ValueSchema<userTypes extends UserTypes | undefined = undefined> = Record<
-  string,
-  userTypes extends UserTypes ? SchemaAbiType | keyof userTypes : SchemaAbiType
->;
-
-/** Map a table schema like `{ value: "uint256" }` to its primitive types like `{ value: bigint }` */
-export type SchemaToPrimitives<TSchema extends ValueSchema> = {
-  [key in keyof TSchema]: SchemaAbiTypeToPrimitiveType<TSchema[key]>;
-};
-
-export type TableRecord<TKeySchema extends KeySchema = KeySchema, TValueSchema extends ValueSchema = ValueSchema> = {
-  key: SchemaToPrimitives<TKeySchema>;
-  value: SchemaToPrimitives<TValueSchema>;
-};
-
-export type ValueArgs = {
-  staticData: Hex;
-  encodedLengths: Hex;
-  dynamicData: Hex;
-};

package/src/decodeDynamicField.test-d.ts

@@ -1,48 +0,0 @@
-import { assertType, describe, it } from "vitest";
-import { Hex } from "viem";
-import { decodeDynamicField } from "./decodeDynamicField";
-
-describe("decodeDynamicField", () => {
-  it("returns a boolean array for bool[] ABI type", () => {
-    assertType<boolean[]>(decodeDynamicField("bool[]", "0x"));
-  });
-
-  it("returns a number array or bigint array for uint[] ABI types", () => {
-    assertType<number[]>(decodeDynamicField("uint8[]", "0x"));
-    assertType<number[]>(decodeDynamicField("uint16[]", "0x"));
-    assertType<number[]>(decodeDynamicField("uint32[]", "0x"));
-    assertType<number[]>(decodeDynamicField("uint48[]", "0x"));
-    assertType<bigint[]>(decodeDynamicField("uint56[]", "0x"));
-    assertType<bigint[]>(decodeDynamicField("uint128[]", "0x"));
-    assertType<bigint[]>(decodeDynamicField("uint256[]", "0x"));
-  });
-
-  it("returns a number array or bigint array for int[] ABI types", () => {
-    assertType<number[]>(decodeDynamicField("int8[]", "0x"));
-    assertType<number[]>(decodeDynamicField("int16[]", "0x"));
-    assertType<number[]>(decodeDynamicField("int32[]", "0x"));
-    assertType<number[]>(decodeDynamicField("int48[]", "0x"));
-    assertType<bigint[]>(decodeDynamicField("int56[]", "0x"));
-    assertType<bigint[]>(decodeDynamicField("int128[]", "0x"));
-    assertType<bigint[]>(decodeDynamicField("int256[]", "0x"));
-  });
-
-  it("returns a hex array for bytes[] ABI types", () => {
-    assertType<Hex[]>(decodeDynamicField("bytes1[]", "0x"));
-    assertType<Hex[]>(decodeDynamicField("bytes2[]", "0x"));
-    assertType<Hex[]>(decodeDynamicField("bytes8[]", "0x"));
-    assertType<Hex[]>(decodeDynamicField("bytes32[]", "0x"));
-  });
-
-  it("returns a hex array for address ABI type", () => {
-    assertType<Hex[]>(decodeDynamicField("address[]", "0x"));
-  });
-
-  it("returns a hex for bytes ABI type", () => {
-    assertType<Hex>(decodeDynamicField("bytes", "0x"));
-  });
-
-  it("returns a string for string ABI type", () => {
-    assertType<string>(decodeDynamicField("string", "0x"));
-  });
-});

package/src/decodeDynamicField.test.ts

@@ -1,175 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { decodeDynamicField } from "./decodeDynamicField";
-
-describe("decodeDynamicField", () => {
-  it("can decode bool[]", () => {
-    expect(decodeDynamicField("bool[]", "0x00")).toStrictEqual([false]);
-    expect(decodeDynamicField("bool[]", "0x01")).toStrictEqual([true]);
-    expect(decodeDynamicField("bool[]", "0x0000")).toStrictEqual([false, false]);
-    expect(decodeDynamicField("bool[]", "0x0001")).toStrictEqual([false, true]);
-    expect(decodeDynamicField("bool[]", "0x0100")).toStrictEqual([true, false]);
-    expect(decodeDynamicField("bool[]", "0x0101")).toStrictEqual([true, true]);
-  });
-
-  it("can decode uint8[]", () => {
-    expect(decodeDynamicField("uint8[]", "0x00")).toStrictEqual([0]);
-    expect(decodeDynamicField("uint8[]", "0x01")).toStrictEqual([1]);
-    expect(decodeDynamicField("uint8[]", "0xff")).toStrictEqual([255]);
-    expect(decodeDynamicField("uint8[]", "0x0000")).toStrictEqual([0, 0]);
-    expect(decodeDynamicField("uint8[]", "0x0101")).toStrictEqual([1, 1]);
-    expect(decodeDynamicField("uint8[]", "0xffff")).toStrictEqual([255, 255]);
-  });
-
-  it("can decode uint256[]", () => {
-    expect(
-      decodeDynamicField("uint256[]", "0x0000000000000000000000000000000000000000000000000000000000000000"),
-    ).toStrictEqual([0n]);
-    expect(
-      decodeDynamicField("uint256[]", "0x0000000000000000000000000000000000000000000000000000000000000001"),
-    ).toStrictEqual([1n]);
-    expect(
-      decodeDynamicField("uint256[]", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
-    ).toStrictEqual([115792089237316195423570985008687907853269984665640564039457584007913129639935n]);
-    expect(
-      decodeDynamicField("uint256[]", "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"),
-    ).toStrictEqual([115792089237316195423570985008687907853269984665640564039457584007913129639934n]);
-    expect(
-      decodeDynamicField(
-        "uint256[]",
-        "0x00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001",
-      ),
-    ).toStrictEqual([1n, 1n]);
-    expect(
-      decodeDynamicField(
-        "uint256[]",
-        "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
-      ),
-    ).toStrictEqual([
-      115792089237316195423570985008687907853269984665640564039457584007913129639935n,
-      115792089237316195423570985008687907853269984665640564039457584007913129639935n,
-    ]);
-  });
-
-  it("can decode int8[]", () => {
-    expect(decodeDynamicField("int8[]", "0x00")).toStrictEqual([0]);
-    expect(decodeDynamicField("int8[]", "0x01")).toStrictEqual([1]);
-    expect(decodeDynamicField("int8[]", "0x7f")).toStrictEqual([127]);
-    expect(decodeDynamicField("int8[]", "0x80")).toStrictEqual([-128]);
-    expect(decodeDynamicField("int8[]", "0x81")).toStrictEqual([-127]);
-    expect(decodeDynamicField("int8[]", "0xff")).toStrictEqual([-1]);
-
-    expect(decodeDynamicField("int8[]", "0x0000")).toStrictEqual([0, 0]);
-    expect(decodeDynamicField("int8[]", "0x0100")).toStrictEqual([1, 0]);
-    expect(decodeDynamicField("int8[]", "0x007f")).toStrictEqual([0, 127]);
-    expect(decodeDynamicField("int8[]", "0x8080")).toStrictEqual([-128, -128]);
-    expect(decodeDynamicField("int8[]", "0x8181")).toStrictEqual([-127, -127]);
-    expect(decodeDynamicField("int8[]", "0x00ff")).toStrictEqual([0, -1]);
-  });
-
-  it("can decode int256[]", () => {
-    expect(
-      decodeDynamicField("int256[]", "0x0000000000000000000000000000000000000000000000000000000000000000"),
-    ).toStrictEqual([0n]);
-    expect(
-      decodeDynamicField("int256[]", "0x0000000000000000000000000000000000000000000000000000000000000001"),
-    ).toStrictEqual([1n]);
-    expect(
-      decodeDynamicField("int256[]", "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
-    ).toStrictEqual([57896044618658097711785492504343953926634992332820282019728792003956564819967n]);
-    expect(
-      decodeDynamicField("int256[]", "0x8000000000000000000000000000000000000000000000000000000000000000"),
-    ).toStrictEqual([-57896044618658097711785492504343953926634992332820282019728792003956564819968n]);
-    expect(
-      decodeDynamicField("int256[]", "0x8000000000000000000000000000000000000000000000000000000000000001"),
-    ).toStrictEqual([-57896044618658097711785492504343953926634992332820282019728792003956564819967n]);
-    expect(
-      decodeDynamicField("int256[]", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
-    ).toStrictEqual([-1n]);
-
-    expect(
-      decodeDynamicField(
-        "int256[]",
-        "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
-      ),
-    ).toStrictEqual([57896044618658097711785492504343953926634992332820282019728792003956564819967n, -1n]);
-    expect(
-      decodeDynamicField(
-        "int256[]",
-        "0x80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-      ),
-    ).toStrictEqual([-57896044618658097711785492504343953926634992332820282019728792003956564819968n, 0n]);
-    expect(
-      decodeDynamicField(
-        "int256[]",
-        "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8000000000000000000000000000000000000000000000000000000000000001",
-      ),
-    ).toStrictEqual([-1n, -57896044618658097711785492504343953926634992332820282019728792003956564819967n]);
-  });
-
-  it("can decode bytes arrays", () => {
-    expect(decodeDynamicField("bytes1[]", "0x01")).toStrictEqual(["0x01"]);
-    expect(decodeDynamicField("bytes1[]", "0x0001")).toStrictEqual(["0x00", "0x01"]);
-    expect(decodeDynamicField("bytes2[]", "0x0001")).toStrictEqual(["0x0001"]);
-    expect(decodeDynamicField("bytes8[]", "0xff00ff00ff00ff00")).toStrictEqual(["0xff00ff00ff00ff00"]);
-    expect(decodeDynamicField("bytes1[]", "0xff00ff00ff00ff00")).toStrictEqual([
-      "0xff",
-      "0x00",
-      "0xff",
-      "0x00",
-      "0xff",
-      "0x00",
-      "0xff",
-      "0x00",
-    ]);
-    expect(decodeDynamicField("bytes2[]", "0xff00ff00ff00ff00")).toStrictEqual([
-      "0xff00",
-      "0xff00",
-      "0xff00",
-      "0xff00",
-    ]);
-    expect(decodeDynamicField("bytes4[]", "0xff00ff00ff00ff00")).toStrictEqual(["0xff00ff00", "0xff00ff00"]);
-    expect(
-      decodeDynamicField("bytes32[]", "0x0000000000000000000000000000000000000000000000000000000000000001"),
-    ).toStrictEqual(["0x0000000000000000000000000000000000000000000000000000000000000001"]);
-    expect(
-      decodeDynamicField(
-        "bytes32[]",
-        "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001",
-      ),
-    ).toStrictEqual([
-      "0x0000000000000000000000000000000000000000000000000000000000000000",
-      "0x0000000000000000000000000000000000000000000000000000000000000001",
-    ]);
-  });
-
-  it("can decode address[]", () => {
-    expect(decodeDynamicField("address[]", "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266")).toStrictEqual([
-      "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-    ]);
-    expect(decodeDynamicField("address[]", "0xffffffffffffffffffffffffffffffffffffffff")).toStrictEqual([
-      "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF",
-    ]);
-
-    expect(() => decodeDynamicField("address[]", "0x00")).toThrow(
-      '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.',
-    );
-  });
-
-  it("can decode bytes", () => {
-    expect(decodeDynamicField("bytes", "0x")).toBe("0x");
-    expect(decodeDynamicField("bytes", "0x01")).toBe("0x01");
-    expect(decodeDynamicField("bytes", "0x0001")).toBe("0x0001");
-    expect(decodeDynamicField("bytes", "0xff00ff00ff00ff00")).toBe("0xff00ff00ff00ff00");
-    expect(decodeDynamicField("bytes", "0x0000000000000000000000000000000000000000000000000000000000000001")).toBe(
-      "0x0000000000000000000000000000000000000000000000000000000000000001",
-    );
-  });
-
-  it("can decode string", () => {
-    expect(decodeDynamicField("string", "0x")).toBe("");
-    expect(decodeDynamicField("string", "0x68656c6c6f")).toBe("hello");
-  });
-});

package/src/decodeDynamicField.ts

@@ -1,145 +0,0 @@
-import { Hex, hexToString, sliceHex } from "viem";
-import { assertExhaustive } from "@latticexyz/common/utils";
-import {
-  DynamicAbiType,
-  DynamicAbiTypeToPrimitiveType,
-  arrayToStaticAbiType,
-  staticAbiTypeToByteLength,
-} from "@latticexyz/schema-type/internal";
-import { decodeStaticField } from "./decodeStaticField";
-import { InvalidHexLengthError, InvalidHexLengthForArrayFieldError } from "./errors";
-
-// TODO: require size/length for dynamic fields, because hex might be longer (sometimes we just move the length pointer of arrays without updating the value)
-//       this means the error should probably change from "invalid length" to "too short", which viem has that we could reuse?
-
-export function decodeDynamicField<
-  TAbiType extends DynamicAbiType,
-  TPrimitiveType extends DynamicAbiTypeToPrimitiveType<TAbiType>,
->(abiType: TAbiType, data: Hex): TPrimitiveType {
-  if (abiType === "bytes") {
-    return data as TPrimitiveType;
-  }
-  if (abiType === "string") {
-    return hexToString(data) as TPrimitiveType;
-  }
-
-  if (data.length > 3 && data.length % 2 !== 0) {
-    throw new InvalidHexLengthError(data);
-  }
-
-  const dataSize = (data.length - 2) / 2;
-
-  switch (abiType) {
-    case "uint8[]":
-    case "uint16[]":
-    case "uint24[]":
-    case "uint32[]":
-    case "uint40[]":
-    case "uint48[]":
-    case "uint56[]":
-    case "uint64[]":
-    case "uint72[]":
-    case "uint80[]":
-    case "uint88[]":
-    case "uint96[]":
-    case "uint104[]":
-    case "uint112[]":
-    case "uint120[]":
-    case "uint128[]":
-    case "uint136[]":
-    case "uint144[]":
-    case "uint152[]":
-    case "uint160[]":
-    case "uint168[]":
-    case "uint176[]":
-    case "uint184[]":
-    case "uint192[]":
-    case "uint200[]":
-    case "uint208[]":
-    case "uint216[]":
-    case "uint224[]":
-    case "uint232[]":
-    case "uint240[]":
-    case "uint248[]":
-    case "uint256[]":
-    case "int8[]":
-    case "int16[]":
-    case "int24[]":
-    case "int32[]":
-    case "int40[]":
-    case "int48[]":
-    case "int56[]":
-    case "int64[]":
-    case "int72[]":
-    case "int80[]":
-    case "int88[]":
-    case "int96[]":
-    case "int104[]":
-    case "int112[]":
-    case "int120[]":
-    case "int128[]":
-    case "int136[]":
-    case "int144[]":
-    case "int152[]":
-    case "int160[]":
-    case "int168[]":
-    case "int176[]":
-    case "int184[]":
-    case "int192[]":
-    case "int200[]":
-    case "int208[]":
-    case "int216[]":
-    case "int224[]":
-    case "int232[]":
-    case "int240[]":
-    case "int248[]":
-    case "int256[]":
-    case "bytes1[]":
-    case "bytes2[]":
-    case "bytes3[]":
-    case "bytes4[]":
-    case "bytes5[]":
-    case "bytes6[]":
-    case "bytes7[]":
-    case "bytes8[]":
-    case "bytes9[]":
-    case "bytes10[]":
-    case "bytes11[]":
-    case "bytes12[]":
-    case "bytes13[]":
-    case "bytes14[]":
-    case "bytes15[]":
-    case "bytes16[]":
-    case "bytes17[]":
-    case "bytes18[]":
-    case "bytes19[]":
-    case "bytes20[]":
-    case "bytes21[]":
-    case "bytes22[]":
-    case "bytes23[]":
-    case "bytes24[]":
-    case "bytes25[]":
-    case "bytes26[]":
-    case "bytes27[]":
-    case "bytes28[]":
-    case "bytes29[]":
-    case "bytes30[]":
-    case "bytes31[]":
-    case "bytes32[]":
-    case "bool[]":
-    case "address[]": {
-      const staticAbiType = arrayToStaticAbiType(abiType);
-      const itemByteLength = staticAbiTypeToByteLength[staticAbiType];
-      if (dataSize % itemByteLength !== 0) {
-        throw new InvalidHexLengthForArrayFieldError(staticAbiType, data);
-      }
-      const items = new Array(dataSize / itemByteLength).fill(undefined).map((_, i) => {
-        const itemData = sliceHex(data, i * itemByteLength, (i + 1) * itemByteLength);
-        return decodeStaticField(staticAbiType, itemData);
-      });
-      return items as TPrimitiveType;
-    }
-  }
-
-  return assertExhaustive(abiType, `Unsupported dynamic ABI type: ${abiType}`);
-}

package/src/decodeField.ts

@@ -1,13 +0,0 @@
-import { Hex } from "viem";
-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>,
->(abiType: TAbiType, data: Hex): TPrimitiveType {
-  return (
-    isDynamicAbiType(abiType) ? decodeDynamicField(abiType, data) : decodeStaticField(abiType, data)
-  ) as TPrimitiveType;
-}

package/src/decodeKey.ts

@@ -1,15 +0,0 @@
-import { Hex } from "viem";
-import { SchemaToPrimitives, KeySchema } from "./common";
-import { decodeKeyTuple } from "./decodeKeyTuple";
-
-export function decodeKey<TSchema extends KeySchema>(
-  keySchema: TSchema,
-  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]]),
-  ) as SchemaToPrimitives<TSchema>;
-}

package/src/decodeKeyTuple.test.ts

@@ -1,37 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { decodeKeyTuple } from "./decodeKeyTuple";
-
-describe("decodeKeyTuple", () => {
-  it("can decode bool key tuple", () => {
-    expect(
-      decodeKeyTuple({ staticFields: ["bool"], dynamicFields: [] }, [
-        "0x0000000000000000000000000000000000000000000000000000000000000000",
-      ]),
-    ).toStrictEqual([false]);
-    expect(
-      decodeKeyTuple({ staticFields: ["bool"], dynamicFields: [] }, [
-        "0x0000000000000000000000000000000000000000000000000000000000000001",
-      ]),
-    ).toStrictEqual([true]);
-  });
-
-  it("can decode complex key tuple", () => {
-    expect(
-      decodeKeyTuple({ staticFields: ["uint256", "int32", "bytes16", "address", "bool", "int8"], dynamicFields: [] }, [
-        "0x000000000000000000000000000000000000000000000000000000000000002a",
-        "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd6",
-        "0x1234000000000000000000000000000000000000000000000000000000000000",
-        "0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff",
-        "0x0000000000000000000000000000000000000000000000000000000000000001",
-        "0x0000000000000000000000000000000000000000000000000000000000000003",
-      ]),
-    ).toStrictEqual([
-      42n,
-      -42,
-      "0x12340000000000000000000000000000",
-      "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF",
-      true,
-      3,
-    ]);
-  });
-});

package/src/decodeKeyTuple.ts

@@ -1,17 +0,0 @@
-import { Hex, decodeAbiParameters } from "viem";
-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
-
-/** @deprecated use `decodeKey` instead */
-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}`,
-    );
-  }
-  return keyTuple.map(
-    (key, index) => decodeAbiParameters([{ type: keySchema.staticFields[index] }], key)[0] as StaticPrimitiveType,
-  );
-}

package/src/decodeRecord.test.ts

@@ -1,36 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { decodeRecord } from "./decodeRecord";
-
-describe("decodeRecord", () => {
-  it("can decode hex to record values", () => {
-    const valueSchema = { staticFields: ["uint32", "uint128"], dynamicFields: ["uint32[]", "string"] } as const;
-    const values = decodeRecord(
-      valueSchema,
-      "0x0000000100000000000000000000000000000002000000000000000000000000000000000000000b0000000008000000000000130000000300000004736f6d6520737472696e67",
-    );
-    expect(values).toStrictEqual([1, 2n, [3, 4], "some string"]);
-  });
-
-  it("can decode an empty record", () => {
-    const valueSchema = { staticFields: [], dynamicFields: ["string", "string"] } as const;
-    const values = decodeRecord(valueSchema, "0x0000000000000000000000000000000000000000000000000000000000000000");
-    expect(values).toMatchInlineSnapshot(`
-      [
-        "",
-        "",
-      ]
-    `);
-  });
-
-  it("can decode an out of bounds array", () => {
-    const valueSchema = { staticFields: [], dynamicFields: ["uint32[]"] } as const;
-    const values = decodeRecord(valueSchema, "0x0000000000000000000000000000000000000000000000000400000000000004");
-    expect(values).toMatchInlineSnapshot(`
-      [
-        [
-          0,
-        ],
-      ]
-    `);
-  });
-});