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

package/src/decodeRecord.ts

@@ -1,72 +0,0 @@
-import {
-  StaticPrimitiveType,
-  DynamicPrimitiveType,
-  staticAbiTypeToByteLength,
-  dynamicAbiTypeToDefaultValue,
-} from "@latticexyz/schema-type/internal";
-import { Hex } from "viem";
-import { Schema } from "./common";
-import { decodeDynamicField } from "./decodeDynamicField";
-import { decodeStaticField } from "./decodeStaticField";
-import { hexToEncodedLengths } from "./hexToEncodedLengths";
-import { staticDataLength } from "./staticDataLength";
-import { readHex } from "@latticexyz/common";
-
-/** @deprecated use `decodeValue` instead */
-export function decodeRecord(valueSchema: Schema, data: Hex): readonly (StaticPrimitiveType | DynamicPrimitiveType)[] {
-  const values: (StaticPrimitiveType | DynamicPrimitiveType)[] = [];
-
-  let bytesOffset = 0;
-  valueSchema.staticFields.forEach((fieldType) => {
-    const fieldByteLength = staticAbiTypeToByteLength[fieldType];
-    const value = decodeStaticField(fieldType, readHex(data, bytesOffset, bytesOffset + fieldByteLength));
-    bytesOffset += fieldByteLength;
-    values.push(value);
-  });
-
-  // Warn user if static data length doesn't match the value schema, because data corruption might be possible.
-  const schemaStaticDataLength = staticDataLength(valueSchema.staticFields);
-  const actualStaticDataLength = bytesOffset;
-  if (actualStaticDataLength !== schemaStaticDataLength) {
-    console.warn(
-      "Decoded static data length does not match value schema's expected static data length. Data may get corrupted. Is `getStaticByteLength` outdated?",
-      {
-        expectedLength: schemaStaticDataLength,
-        actualLength: actualStaticDataLength,
-        bytesOffset,
-      },
-    );
-  }
-
-  if (valueSchema.dynamicFields.length > 0) {
-    const dataLayout = hexToEncodedLengths(readHex(data, bytesOffset, bytesOffset + 32));
-    bytesOffset += 32;
-
-    valueSchema.dynamicFields.forEach((fieldType, i) => {
-      const dataLength = dataLayout.fieldByteLengths[i];
-      if (dataLength > 0) {
-        const value = decodeDynamicField(fieldType, readHex(data, bytesOffset, bytesOffset + dataLength));
-        bytesOffset += dataLength;
-        values.push(value);
-      } else {
-        values.push(dynamicAbiTypeToDefaultValue[fieldType]);
-      }
-    });
-
-    // Warn user if dynamic data length doesn't match the dynamic data length, because data corruption might be possible.
-    const actualDynamicDataLength = bytesOffset - 32 - actualStaticDataLength;
-    // TODO: refactor this so we don't break for bytes offsets >UINT40
-    if (BigInt(actualDynamicDataLength) !== dataLayout.totalByteLength) {
-      console.warn(
-        "Decoded dynamic data length does not match data layout's expected data length. Data may get corrupted. Did the data layout change?",
-        {
-          expectedLength: dataLayout.totalByteLength,
-          actualLength: actualDynamicDataLength,
-          bytesOffset,
-        },
-      );
-    }
-  }
-
-  return values;
-}

package/src/decodeStaticField.test-d.ts

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

package/src/decodeStaticField.test.ts

@@ -1,94 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { decodeStaticField } from "./decodeStaticField";
-
-describe("decodeStaticField", () => {
-  it("can decode bool", () => {
-    expect(decodeStaticField("bool", "0x00")).toBe(false);
-    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.',
-    );
-    expect(() => decodeStaticField("bool", "0x1")).toThrow(
-      '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.',
-    );
-    expect(() => decodeStaticField("bool", "0x001")).toThrow(
-      '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.',
-    );
-    expect(() => decodeStaticField("bool", "0x0001")).toThrow(
-      'Hex value "0x0001" has length of 4, but expected length of 2 for bool type.',
-    );
-  });
-
-  it("can decode uint8", () => {
-    expect(decodeStaticField("uint8", "0x00")).toBe(0);
-    expect(decodeStaticField("uint8", "0x01")).toBe(1);
-    expect(decodeStaticField("uint8", "0xff")).toBe(255);
-  });
-
-  it("can decode uint256", () => {
-    expect(decodeStaticField("uint256", "0x0000000000000000000000000000000000000000000000000000000000000000")).toBe(0n);
-    expect(decodeStaticField("uint256", "0x0000000000000000000000000000000000000000000000000000000000000001")).toBe(1n);
-    expect(decodeStaticField("uint256", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")).toBe(
-      115792089237316195423570985008687907853269984665640564039457584007913129639935n,
-    );
-    expect(decodeStaticField("uint256", "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe")).toBe(
-      115792089237316195423570985008687907853269984665640564039457584007913129639934n,
-    );
-  });
-
-  it("can decode int8", () => {
-    expect(decodeStaticField("int8", "0x00")).toBe(0);
-    expect(decodeStaticField("int8", "0x01")).toBe(1);
-    expect(decodeStaticField("int8", "0x7f")).toBe(127);
-    expect(decodeStaticField("int8", "0x80")).toBe(-128);
-    expect(decodeStaticField("int8", "0x81")).toBe(-127);
-    expect(decodeStaticField("int8", "0xff")).toBe(-1);
-  });
-
-  it("can decode int256", () => {
-    expect(decodeStaticField("int256", "0x0000000000000000000000000000000000000000000000000000000000000000")).toBe(0n);
-    expect(decodeStaticField("int256", "0x0000000000000000000000000000000000000000000000000000000000000001")).toBe(1n);
-    expect(decodeStaticField("int256", "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")).toBe(
-      57896044618658097711785492504343953926634992332820282019728792003956564819967n,
-    );
-    expect(decodeStaticField("int256", "0x8000000000000000000000000000000000000000000000000000000000000000")).toBe(
-      -57896044618658097711785492504343953926634992332820282019728792003956564819968n,
-    );
-    expect(decodeStaticField("int256", "0x8000000000000000000000000000000000000000000000000000000000000001")).toBe(
-      -57896044618658097711785492504343953926634992332820282019728792003956564819967n,
-    );
-    expect(decodeStaticField("int256", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")).toBe(-1n);
-  });
-
-  it("can decode bytes", () => {
-    expect(decodeStaticField("bytes1", "0x01")).toBe("0x01");
-    expect(decodeStaticField("bytes2", "0x0001")).toBe("0x0001");
-    expect(decodeStaticField("bytes8", "0xff00ff00ff00ff00")).toBe("0xff00ff00ff00ff00");
-    expect(decodeStaticField("bytes32", "0x0000000000000000000000000000000000000000000000000000000000000001")).toBe(
-      "0x0000000000000000000000000000000000000000000000000000000000000001",
-    );
-  });
-
-  it("can decode address", () => {
-    expect(decodeStaticField("address", "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266")).toBe(
-      "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-    );
-    expect(decodeStaticField("address", "0xffffffffffffffffffffffffffffffffffffffff")).toBe(
-      "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF",
-    );
-
-    expect(() => decodeStaticField("address", "0x00")).toThrow(
-      '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.',
-    );
-  });
-});

package/src/decodeStaticField.ts

@@ -1,145 +0,0 @@
-import { Hex, getAddress, hexToBigInt, hexToBool } from "viem";
-import { assertExhaustive } from "@latticexyz/common/utils";
-import {
-  StaticAbiType,
-  StaticAbiTypeToPrimitiveType,
-  staticAbiTypeToByteLength,
-  staticAbiTypeToDefaultValue,
-} from "@latticexyz/schema-type/internal";
-import { InvalidHexLengthError, InvalidHexLengthForStaticFieldError } from "./errors";
-
-export function decodeStaticField<
-  TAbiType extends StaticAbiType,
-  TPrimitiveType extends StaticAbiTypeToPrimitiveType<TAbiType>,
->(abiType: TAbiType, data: Hex): TPrimitiveType {
-  if (data.length > 3 && data.length % 2 !== 0) {
-    throw new InvalidHexLengthError(data);
-  }
-
-  const dataSize = (data.length - 2) / 2;
-  if (dataSize !== staticAbiTypeToByteLength[abiType]) {
-    throw new InvalidHexLengthForStaticFieldError(abiType, data);
-  }
-
-  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": {
-      const value = hexToBigInt(data, { signed: abiType.startsWith("int") });
-      const defaultValueType = typeof staticAbiTypeToDefaultValue[abiType];
-      if (defaultValueType === "number") {
-        return Number(value) as TPrimitiveType;
-      }
-      if (defaultValueType === "bigint") {
-        return value as TPrimitiveType;
-      }
-      throw new Error(`Unexpected default value type (${defaultValueType}) for ABI type (${abiType})`);
-    }
-
-    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": {
-      return data as TPrimitiveType;
-    }
-
-    case "bool": {
-      return hexToBool(data) as TPrimitiveType;
-    }
-
-    case "address": {
-      return getAddress(data) as TPrimitiveType;
-    }
-  }
-
-  return assertExhaustive(abiType, `Unsupported static ABI type: ${abiType}`);
-}

package/src/decodeValue.ts

@@ -1,16 +0,0 @@
-import { isStaticAbiType, isDynamicAbiType } from "@latticexyz/schema-type/internal";
-import { Hex } from "viem";
-import { SchemaToPrimitives, ValueSchema } from "./common";
-import { decodeRecord } from "./decodeRecord";
-
-export function decodeValue<TSchema extends ValueSchema>(valueSchema: TSchema, data: Hex): SchemaToPrimitives<TSchema> {
-  const staticFields = Object.values(valueSchema).filter(isStaticAbiType);
-  const dynamicFields = Object.values(valueSchema).filter(isDynamicAbiType);
-
-  // TODO: refactor and move all decodeRecord logic into this method so we can delete decodeRecord
-  const valueTuple = decodeRecord({ staticFields, dynamicFields }, data);
-
-  return Object.fromEntries(
-    Object.keys(valueSchema).map((name, i) => [name, valueTuple[i]]),
-  ) as SchemaToPrimitives<TSchema>;
-}

package/src/decodeValueArgs.ts

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

package/src/encodeField.ts

@@ -1,20 +0,0 @@
-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 }>,
-): Hex {
-  if (isArrayAbiType(fieldType) && Array.isArray(value)) {
-    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,
-        );
-  }
-  return encodePacked([fieldType], [value]);
-}

package/src/encodeKey.ts

@@ -1,13 +0,0 @@
-import { isStaticAbiType } from "@latticexyz/schema-type/internal";
-import { Hex } from "viem";
-import { SchemaToPrimitives, KeySchema } from "./common";
-import { encodeKeyTuple } from "./encodeKeyTuple";
-
-export function encodeKey<TSchema extends KeySchema>(
-  keySchema: TSchema,
-  key: SchemaToPrimitives<TSchema>,
-): readonly Hex[] {
-  const staticFields = Object.values(keySchema).filter(isStaticAbiType);
-  // TODO: refactor and move all encodeKeyTuple logic into this method so we can delete encodeKeyTuple
-  return encodeKeyTuple({ staticFields, dynamicFields: [] }, Object.values(key));
-}

package/src/encodeKeyTuple.test.ts

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

package/src/encodeKeyTuple.ts

@@ -1,8 +0,0 @@
-import { StaticPrimitiveType } from "@latticexyz/schema-type/internal";
-import { Hex, encodeAbiParameters } from "viem";
-import { Schema } from "./common";
-
-/** @deprecated use `encodeKey` instead */
-export function encodeKeyTuple(keySchema: Schema, keyTuple: StaticPrimitiveType[]): Hex[] {
-  return keyTuple.map((key, index) => encodeAbiParameters([{ type: keySchema.staticFields[index] }], [key]));
-}

package/src/encodeLengths.test.ts

@@ -1,16 +0,0 @@
-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"',
-    );
-  });
-});

package/src/encodeLengths.ts

@@ -1,12 +0,0 @@
-import { Hex, concatHex, padHex, size } from "viem";
-import { encodeField } from "./encodeField";
-
-export function encodeLengths(values: Hex[]): Hex {
-  const byteLengths = values.map(size).reverse();
-  const totalByteLength = byteLengths.reduce((total, length) => total + BigInt(length), 0n);
-
-  return padHex(
-    concatHex([...byteLengths.map((length) => encodeField("uint40", length)), encodeField("uint56", totalByteLength)]),
-    { size: 32, dir: "left" },
-  );
-}

package/src/encodeRecord.test.ts

@@ -1,24 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { encodeRecord } from "./encodeRecord";
-
-describe("encodeRecord", () => {
-  it("can encode a value schema and record values to hex", () => {
-    const valueSchema = { staticFields: ["uint32", "uint128"], dynamicFields: ["uint32[]", "string"] } as const;
-    const hex = encodeRecord(valueSchema, [1, 2n, [3, 4], "some string"]);
-    expect(hex).toBe(
-      "0x0000000100000000000000000000000000000002000000000000000000000000000000000000000b0000000008000000000000130000000300000004736f6d6520737472696e67",
-    );
-  });
-
-  it("should not include the packed dynamic lengths if there are no dynamic fields", () => {
-    const valueSchema = { staticFields: ["uint32", "uint128"], dynamicFields: [] } as const;
-    const hex = encodeRecord(valueSchema, [1, 2n]);
-    expect(hex).toBe("0x0000000100000000000000000000000000000002");
-  });
-
-  it("can encode an array to hex", () => {
-    const valueSchema = { staticFields: [], dynamicFields: ["uint32[]"] } as const;
-    const hex = encodeRecord(valueSchema, [[42]]);
-    expect(hex).toBe("0x00000000000000000000000000000000000000000000000004000000000000040000002a");
-  });
-});

package/src/encodeRecord.ts

@@ -1,34 +0,0 @@
-import { StaticPrimitiveType, DynamicPrimitiveType } from "@latticexyz/schema-type/internal";
-import { Hex } from "viem";
-import { encodeField } from "./encodeField";
-import { Schema } from "./common";
-
-/** @deprecated use `encodeValue` instead */
-export function encodeRecord(
-  valueSchema: Schema,
-  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[];
-
-  const staticData = staticValues
-    .map((value, i) => encodeField(valueSchema.staticFields[i], value).replace(/^0x/, ""))
-    .join("");
-
-  if (valueSchema.dynamicFields.length === 0) return `0x${staticData}`;
-
-  const dynamicDataItems = dynamicValues.map((value, i) =>
-    encodeField(valueSchema.dynamicFields[i], value).replace(/^0x/, ""),
-  );
-
-  const dynamicFieldByteLengths = dynamicDataItems.map((value) => value.length / 2).reverse();
-  const dynamicTotalByteLength = dynamicFieldByteLengths.reduce((total, length) => total + BigInt(length), 0n);
-
-  const dynamicData = dynamicDataItems.join("");
-
-  const encodedLengths = `${dynamicFieldByteLengths
-    .map((length) => encodeField("uint40", length).replace(/^0x/, ""))
-    .join("")}${encodeField("uint56", dynamicTotalByteLength).replace(/^0x/, "")}`.padStart(64, "0");
-
-  return `0x${staticData}${encodedLengths}${dynamicData}`;
-}

package/src/encodeValue.ts

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

package/src/encodeValueArgs.test.ts

@@ -1,53 +0,0 @@
-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",
-      }
-    `);
-  });
-});

package/src/encodeValueArgs.ts

@@ -1,36 +0,0 @@
-import {
-  StaticPrimitiveType,
-  DynamicPrimitiveType,
-  isStaticAbiType,
-  isDynamicAbiType,
-  StaticAbiType,
-  DynamicAbiType,
-} from "@latticexyz/schema-type/internal";
-import { concatHex } from "viem";
-import { encodeField } from "./encodeField";
-import { SchemaToPrimitives, ValueArgs, ValueSchema } from "./common";
-import { encodeLengths } from "./encodeLengths";
-
-export function encodeValueArgs<TSchema extends ValueSchema>(
-  valueSchema: TSchema,
-  value: SchemaToPrimitives<TSchema>,
-): ValueArgs {
-  const valueSchemaEntries = Object.entries(valueSchema);
-  const staticFields = valueSchemaEntries.filter(([, type]) => isStaticAbiType(type)) as [string, StaticAbiType][];
-  const dynamicFields = valueSchemaEntries.filter(([, type]) => isDynamicAbiType(type)) as [string, DynamicAbiType][];
-  // TODO: validate <=5 dynamic fields
-  // TODO: validate <=28 total fields
-
-  const encodedStaticValues = staticFields.map(([name, type]) => encodeField(type, value[name] as StaticPrimitiveType));
-  const encodedDynamicValues = dynamicFields.map(([name, type]) =>
-    encodeField(type, value[name] as DynamicPrimitiveType),
-  );
-
-  const encodedLengths = encodeLengths(encodedDynamicValues);
-
-  return {
-    staticData: concatHex(encodedStaticValues),
-    encodedLengths,
-    dynamicData: concatHex(encodedDynamicValues),
-  };
-}