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

package/src/errors.ts

@@ -1,65 +0,0 @@
-import { Hex } from "viem";
-import { MUDError } from "@latticexyz/common/errors";
-import { StaticAbiType, staticAbiTypeToByteLength } from "@latticexyz/schema-type/internal";
-
-export class InvalidHexLengthError extends MUDError {
-  override name = "InvalidHexValueError";
-  constructor(value: Hex) {
-    super(`Hex value "${value}" is an odd length (${value.length - 2}). It must be an even length.`);
-  }
-}
-
-export class InvalidHexLengthForSchemaError extends MUDError {
-  override name = "InvalidHexLengthForSchemaError";
-  constructor(value: Hex) {
-    super(`Hex value "${value}" has length of ${value.length - 2}, but expected length of 64 for a schema.`);
-  }
-}
-
-export class InvalidHexLengthForEncodedLengthsError extends MUDError {
-  override name = "InvalidHexLengthForEncodedLengthsError";
-  constructor(value: Hex) {
-    super(`Hex value "${value}" has length of ${value.length - 2}, but expected length of 64 for encoded lengths.`);
-  }
-}
-
-export class InvalidHexLengthForStaticFieldError extends MUDError {
-  override name = "InvalidHexLengthForStaticFieldError";
-  constructor(abiType: StaticAbiType, value: Hex) {
-    super(
-      `Hex value "${value}" has length of ${value.length - 2}, but expected length of ${
-        staticAbiTypeToByteLength[abiType] * 2
-      } for ${abiType} type.`,
-    );
-  }
-}
-
-export class InvalidHexLengthForArrayFieldError extends MUDError {
-  override name = "InvalidHexLengthForArrayFieldError";
-  constructor(abiType: StaticAbiType, value: Hex) {
-    super(
-      `Hex value "${value}" has length of ${value.length - 2}, but expected a multiple of ${
-        staticAbiTypeToByteLength[abiType] * 2
-      } for ${abiType}[] type.`,
-    );
-  }
-}
-
-export class SchemaStaticLengthMismatchError extends MUDError {
-  override name = "SchemaStaticLengthMismatchError";
-  constructor(schemaData: Hex, definedLength: number, summedLength: number) {
-    super(
-      `Schema "${schemaData}" static data length (${definedLength}) did not match the summed length of all static fields (${summedLength}). ` +
-        `Is \`staticAbiTypeToByteLength\` up to date with Solidity schema types?`,
-    );
-  }
-}
-
-export class EncodedLengthsLengthMismatchError extends MUDError {
-  override name = "EncodedLengthsLengthMismatchError";
-  constructor(encodedLengthsData: Hex, definedLength: bigint, summedLength: bigint) {
-    super(
-      `EncodedLengths "${encodedLengthsData}" total bytes length (${definedLength}) did not match the summed length of all field byte lengths (${summedLength}).`,
-    );
-  }
-}

package/src/exports/index.ts

@@ -1,5 +0,0 @@
-/**
- * External exports.
- *
- * Be sure we're ready to commit to these being supported and changes made backward compatible!
- */

package/src/exports/internal.ts

@@ -1,31 +0,0 @@
-export * from "../abiTypesToSchema";
-export * from "../common";
-export * from "../decodeDynamicField";
-export * from "../decodeField";
-export * from "../decodeKey";
-export * from "../decodeKeyTuple";
-export * from "../decodeRecord";
-export * from "../decodeStaticField";
-export * from "../decodeValue";
-export * from "../decodeValueArgs";
-export * from "../encodeField";
-export * from "../encodeKey";
-export * from "../encodeKeyTuple";
-export * from "../encodeRecord";
-export * from "../encodeValue";
-export * from "../encodeValueArgs";
-export * from "../errors";
-export * from "../fieldLayoutToHex";
-export * from "../hexToEncodedLengths";
-export * from "../hexToSchema";
-export * from "../hexToTableSchema";
-export * from "../keySchemaToHex";
-export * from "../schemaIndexToAbiType";
-export * from "../schemaToHex";
-export * from "../staticDataLength";
-export * from "../valueSchemaToFieldLayoutHex";
-export * from "../valueSchemaToHex";
-
-export * from "../getKeySchema";
-export * from "../getValueSchema";
-export * from "../getSchemaTypes";

package/src/fieldLayoutToHex.ts

@@ -1,15 +0,0 @@
-import { Hex } from "viem";
-import { FieldLayout } from "./common";
-
-/** @deprecated use `valueSchemaToFieldLayoutHex` instead */
-export function fieldLayoutToHex(fieldLayout: FieldLayout): Hex {
-  const staticDataLength = fieldLayout.staticFieldLengths.reduce((totalLength, length) => totalLength + length, 0);
-  return `0x${[
-    staticDataLength.toString(16).padStart(4, "0"),
-    fieldLayout.staticFieldLengths.length.toString(16).padStart(2, "0"),
-    fieldLayout.numDynamicFields.toString(16).padStart(2, "0"),
-    ...fieldLayout.staticFieldLengths.map((schemaType) => schemaType.toString(16).padStart(2, "0")),
-  ]
-    .join("")
-    .padEnd(64, "0")}`;
-}

package/src/getKeySchema.ts

@@ -1,9 +0,0 @@
-import { Table } from "@latticexyz/config";
-
-export type getKeySchema<table extends Table> = {
-  [fieldName in table["key"][number]]: table["schema"][fieldName];
-};
-
-export function getKeySchema<table extends Table>(table: table): getKeySchema<table> {
-  return Object.fromEntries(table.key.map((fieldName) => [fieldName, table.schema[fieldName]])) as getKeySchema<table>;
-}

package/src/getSchemaTypes.ts

@@ -1,10 +0,0 @@
-import { Schema } from "@latticexyz/config";
-import { mapObject } from "@latticexyz/common/utils";
-
-export type getSchemaTypes<schema extends Schema> = {
-  readonly [k in keyof schema]: schema[k]["type"];
-};
-
-export function getSchemaTypes<schema extends Schema>(schema: schema): getSchemaTypes<schema> {
-  return mapObject(schema, (value) => value.type);
-}

package/src/getValueSchema.ts

@@ -1,11 +0,0 @@
-import { Table } from "@latticexyz/config";
-
-export type getValueSchema<table extends Table> = {
-  [fieldName in Exclude<keyof table["schema"], table["key"][number]>]: table["schema"][fieldName];
-};
-
-export function getValueSchema<table extends Table>(table: table): getValueSchema<table> {
-  return Object.fromEntries(
-    Object.entries(table.schema).filter(([fieldName]) => !table.key.includes(fieldName)),
-  ) as getValueSchema<table>;
-}

package/src/hexToEncodedLengths.test.ts

@@ -1,35 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { hexToEncodedLengths } from "./hexToEncodedLengths";
-
-describe("hexToEncodedLengths", () => {
-  it("decodes hex data to encoded lengths", () => {
-    expect(hexToEncodedLengths("0x0000000000000000000000000000400000000020000000002000000000000080"))
-      .toMatchInlineSnapshot(`
-      {
-        "fieldByteLengths": [
-          32,
-          32,
-          64,
-          0,
-          0,
-        ],
-        "totalByteLength": 128n,
-      }
-    `);
-  });
-
-  it("throws if schema hex data is not bytes32", () => {
-    expect(() => hexToEncodedLengths("0x01234")).toThrowErrorMatchingInlineSnapshot(
-      '"Hex value \\"0x01234\\" has length of 5, but expected length of 64 for encoded lengths."',
-    );
-  });
-
-  it("throws if encoded lengths total byte length doesn't match summed byte length of fields", () => {
-    expect(() =>
-      hexToEncodedLengths("0x0000000000000000000000000000400000000020000000002000000000000040"),
-    ).toThrowErrorMatchingInlineSnapshot(
-      // eslint-disable-next-line max-len
-      '"EncodedLengths \\"0x0000000000000000000000000000400000000020000000002000000000000040\\" total bytes length (64) did not match the summed length of all field byte lengths (128)."',
-    );
-  });
-});

package/src/hexToEncodedLengths.ts

@@ -1,34 +0,0 @@
-import { Hex } from "viem";
-import { decodeStaticField } from "./decodeStaticField";
-import { decodeDynamicField } from "./decodeDynamicField";
-import { InvalidHexLengthForEncodedLengthsError, EncodedLengthsLengthMismatchError } from "./errors";
-import { readHex } from "@latticexyz/common";
-
-// Keep this logic in sync with EncodedLengths.sol
-
-// - Last 7 bytes (uint56) are used for the total byte length of the dynamic data
-// - The next 5 byte (uint40) sections are used for the byte length of each field, indexed from right to left
-
-// We use byte lengths rather than item counts so that, on chain, we can slice without having to get the value schema first (and thus the field lengths of each dynamic type)
-
-export function hexToEncodedLengths(data: Hex): {
-  totalByteLength: bigint;
-  fieldByteLengths: readonly number[];
-} {
-  if (data.length !== 66) {
-    throw new InvalidHexLengthForEncodedLengthsError(data);
-  }
-
-  const totalByteLength = decodeStaticField("uint56", readHex(data, 32 - 7, 32));
-  // TODO: use value schema to make sure we only parse as many as we need (rather than zeroes at the end)?
-  const reversedFieldByteLengths = decodeDynamicField("uint40[]", readHex(data, 0, 32 - 7));
-  // Reverse the lengths
-  const fieldByteLengths = Object.freeze([...reversedFieldByteLengths].reverse());
-
-  const summedLength = BigInt(fieldByteLengths.reduce((total, length) => total + length, 0));
-  if (summedLength !== totalByteLength) {
-    throw new EncodedLengthsLengthMismatchError(data, totalByteLength, summedLength);
-  }
-
-  return { totalByteLength, fieldByteLengths };
-}

package/src/hexToSchema.test.ts

@@ -1,68 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { hexToSchema } from "./hexToSchema";
-
-describe("hexToSchema", () => {
-  it("converts hex to schema", () => {
-    expect(hexToSchema("0x0001010060000000000000000000000000000000000000000000000000000000")).toMatchInlineSnapshot(`
-      {
-        "dynamicFields": [],
-        "staticFields": [
-          "bool",
-        ],
-      }
-    `);
-    expect(hexToSchema("0x0001010160c20000000000000000000000000000000000000000000000000000")).toMatchInlineSnapshot(`
-      {
-        "dynamicFields": [
-          "bool[]",
-        ],
-        "staticFields": [
-          "bool",
-        ],
-      }
-    `);
-    expect(hexToSchema("0x002402045f2381c3c4c500000000000000000000000000000000000000000000")).toMatchInlineSnapshot(`
-      {
-        "dynamicFields": [
-          "uint256[]",
-          "address[]",
-          "bytes",
-          "string",
-        ],
-        "staticFields": [
-          "bytes32",
-          "int32",
-        ],
-      }
-    `);
-
-    expect(hexToSchema("0x00570800616100030700001f0000000000000000000000000000000000000000")).toMatchInlineSnapshot(`
-      {
-        "dynamicFields": [],
-        "staticFields": [
-          "address",
-          "address",
-          "uint8",
-          "uint32",
-          "uint64",
-          "uint8",
-          "uint8",
-          "uint256",
-        ],
-      }
-    `);
-  });
-
-  it("throws if schema hex data is not bytes32", () => {
-    expect(() => hexToSchema("0x002502045f2381c3c4c5")).toThrow(
-      'Hex value "0x002502045f2381c3c4c5" has length of 20, but expected length of 64 for a schema.',
-    );
-  });
-
-  it("throws if schema static field lengths do not match", () => {
-    expect(() => hexToSchema("0x002502045f2381c3c4c500000000000000000000000000000000000000000000")).toThrow(
-      // eslint-disable-next-line max-len
-      'Schema "0x002502045f2381c3c4c500000000000000000000000000000000000000000000" static data length (37) did not match the summed length of all static fields (36). Is `staticAbiTypeToByteLength` up to date with Solidity schema types?',
-    );
-  });
-});

package/src/hexToSchema.ts

@@ -1,42 +0,0 @@
-import {
-  StaticAbiType,
-  DynamicAbiType,
-  schemaAbiTypes,
-  staticAbiTypeToByteLength,
-} from "@latticexyz/schema-type/internal";
-import { Hex, hexToNumber, sliceHex } from "viem";
-import { Schema } from "./common";
-import { InvalidHexLengthForSchemaError, SchemaStaticLengthMismatchError } from "./errors";
-
-export function hexToSchema(data: Hex): Schema {
-  if (data.length !== 66) {
-    throw new InvalidHexLengthForSchemaError(data);
-  }
-
-  const staticDataLength = hexToNumber(sliceHex(data, 0, 2));
-  const numStaticFields = hexToNumber(sliceHex(data, 2, 3));
-  const numDynamicFields = hexToNumber(sliceHex(data, 3, 4));
-  const staticFields: StaticAbiType[] = [];
-  const dynamicFields: DynamicAbiType[] = [];
-
-  for (let i = 4; i < 4 + numStaticFields; i++) {
-    const schemaTypeIndex = hexToNumber(sliceHex(data, i, i + 1));
-    staticFields.push(schemaAbiTypes[schemaTypeIndex] as StaticAbiType);
-  }
-  for (let i = 4 + numStaticFields; i < 4 + numStaticFields + numDynamicFields; i++) {
-    const schemaTypeIndex = hexToNumber(sliceHex(data, i, i + 1));
-    dynamicFields.push(schemaAbiTypes[schemaTypeIndex] as DynamicAbiType);
-  }
-
-  // validate static data length
-  const actualStaticDataLength = staticFields.reduce((acc, fieldType) => acc + staticAbiTypeToByteLength[fieldType], 0);
-  if (actualStaticDataLength !== staticDataLength) {
-    console.warn(
-      `Schema "${data}" static data length (${staticDataLength}) did not match the summed length of all static fields (${actualStaticDataLength}). ` +
-        `Is \`staticAbiTypeToByteLength\` up to date with Solidity schema types?`,
-    );
-    throw new SchemaStaticLengthMismatchError(data, staticDataLength, actualStaticDataLength);
-  }
-
-  return { staticFields, dynamicFields };
-}

package/src/hexToTableSchema.ts

@@ -1,12 +0,0 @@
-import { Hex, sliceHex } from "viem";
-import { TableSchema } from "./common";
-import { hexToSchema } from "./hexToSchema";
-
-export function hexToTableSchema(data: Hex): TableSchema {
-  const valueSchema = hexToSchema(sliceHex(data, 0, 32));
-  const keySchema = hexToSchema(sliceHex(data, 32, 64));
-  return {
-    keySchema,
-    valueSchema,
-  };
-}

package/src/keySchemaToHex.ts

@@ -1,8 +0,0 @@
-import { isStaticAbiType } from "@latticexyz/schema-type/internal";
-import { Hex } from "viem";
-import { KeySchema } from "./common";
-import { schemaToHex } from "./schemaToHex";
-
-export function keySchemaToHex(keySchema: KeySchema): Hex {
-  return schemaToHex({ staticFields: Object.values(keySchema).filter(isStaticAbiType), dynamicFields: [] });
-}

package/src/schemaIndexToAbiType.ts

@@ -1,9 +0,0 @@
-import { SchemaAbiType } from "@latticexyz/schema-type/internal";
-import { Schema } from "./common";
-
-export function schemaIndexToAbiType(schema: Schema, schemaIndex: number): SchemaAbiType {
-  if (schemaIndex < schema.staticFields.length) {
-    return schema.staticFields[schemaIndex];
-  }
-  return schema.dynamicFields[schemaIndex - schema.staticFields.length];
-}

package/src/schemaToHex.test.ts

@@ -1,16 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { schemaToHex } from "./schemaToHex";
-
-describe("schemaToHex", () => {
-  it("converts schema to hex", () => {
-    expect(schemaToHex({ staticFields: ["bool"], dynamicFields: [] })).toBe(
-      "0x0001010060000000000000000000000000000000000000000000000000000000",
-    );
-    expect(schemaToHex({ staticFields: ["bool"], dynamicFields: ["bool[]"] })).toBe(
-      "0x0001010160c20000000000000000000000000000000000000000000000000000",
-    );
-    expect(
-      schemaToHex({ staticFields: ["bytes32", "int32"], dynamicFields: ["uint256[]", "address[]", "bytes", "string"] }),
-    ).toBe("0x002402045f2381c3c4c500000000000000000000000000000000000000000000");
-  });
-});

package/src/schemaToHex.ts

@@ -1,19 +0,0 @@
-import { schemaAbiTypes } from "@latticexyz/schema-type/internal";
-import { Hex } from "viem";
-import { Schema } from "./common";
-import { staticDataLength } from "./staticDataLength";
-
-/** @deprecated use `keySchemaToHex` or `valueSchemaToHex` instead */
-export function schemaToHex(schema: Schema): Hex {
-  const staticSchemaTypes = schema.staticFields.map((abiType) => schemaAbiTypes.indexOf(abiType));
-  const dynamicSchemaTypes = schema.dynamicFields.map((abiType) => schemaAbiTypes.indexOf(abiType));
-  return `0x${[
-    staticDataLength(schema.staticFields).toString(16).padStart(4, "0"),
-    schema.staticFields.length.toString(16).padStart(2, "0"),
-    schema.dynamicFields.length.toString(16).padStart(2, "0"),
-    ...staticSchemaTypes.map((schemaType) => schemaType.toString(16).padStart(2, "0")),
-    ...dynamicSchemaTypes.map((schemaType) => schemaType.toString(16).padStart(2, "0")),
-  ]
-    .join("")
-    .padEnd(64, "0")}`;
-}

package/src/staticDataLength.ts

@@ -1,5 +0,0 @@
-import { StaticAbiType, staticAbiTypeToByteLength } from "@latticexyz/schema-type/internal";
-
-export function staticDataLength(staticFields: readonly StaticAbiType[]): number {
-  return staticFields.reduce((length, fieldType) => length + staticAbiTypeToByteLength[fieldType], 0);
-}

package/src/valueSchemaToFieldLayoutHex.ts

@@ -1,21 +0,0 @@
-import { Hex } from "viem";
-import { ValueSchema } from "./common";
-import { isDynamicAbiType, isStaticAbiType, staticAbiTypeToByteLength } from "@latticexyz/schema-type/internal";
-
-// TODO: add tests once we have corresponding tests for FieldLayout.sol (bytes32 -> FieldLayout and vice versa)
-export function valueSchemaToFieldLayoutHex(valueSchema: ValueSchema): Hex {
-  const staticFields = Object.values(valueSchema).filter(isStaticAbiType);
-  const dynamicFields = Object.values(valueSchema).filter(isDynamicAbiType);
-
-  const staticFieldLengths = staticFields.map((fieldType) => staticAbiTypeToByteLength[fieldType]);
-  const staticDataLength = staticFieldLengths.reduce((dataLength, fieldLength) => dataLength + fieldLength, 0);
-
-  return `0x${[
-    staticDataLength.toString(16).padStart(4, "0"),
-    staticFields.length.toString(16).padStart(2, "0"),
-    dynamicFields.length.toString(16).padStart(2, "0"),
-    ...staticFieldLengths.map((fieldLength) => fieldLength.toString(16).padStart(2, "0")),
-  ]
-    .join("")
-    .padEnd(64, "0")}`;
-}

package/src/valueSchemaToHex.ts

@@ -1,11 +0,0 @@
-import { isDynamicAbiType, isStaticAbiType } from "@latticexyz/schema-type/internal";
-import { Hex } from "viem";
-import { ValueSchema } from "./common";
-import { schemaToHex } from "./schemaToHex";
-
-export function valueSchemaToHex(valueSchema: ValueSchema): Hex {
-  return schemaToHex({
-    staticFields: Object.values(valueSchema).filter(isStaticAbiType),
-    dynamicFields: Object.values(valueSchema).filter(isDynamicAbiType),
-  });
-}