@latticexyz/protocol-parser 0.0.0-indexing-20230707130424

package/src/hexToSchema.test.ts

@@ -0,0 +1,51 @@
+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",
+        ],
+      }
+    `);
+  });
+
+  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(
+      '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

@@ -0,0 +1,33 @@
+import { StaticAbiType, DynamicAbiType, schemaAbiTypes, staticAbiTypeToByteLength } from "@latticexyz/schema-type";
+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) {
+    throw new SchemaStaticLengthMismatchError(data, staticDataLength, actualStaticDataLength);
+  }
+
+  return { staticFields, dynamicFields };
+}

package/src/hexToTableSchema.ts

@@ -0,0 +1,12 @@
+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/index.ts

@@ -0,0 +1,17 @@
+export * from "./abiTypesToSchema";
+export * from "./common";
+export * from "./decodeDynamicField";
+export * from "./decodeField";
+export * from "./decodeKeyTuple";
+export * from "./decodeRecord";
+export * from "./decodeStaticField";
+export * from "./encodeField";
+export * from "./encodeKeyTuple";
+export * from "./encodeRecord";
+export * from "./errors";
+export * from "./hexToPackedCounter";
+export * from "./hexToSchema";
+export * from "./hexToTableSchema";
+export * from "./schemaIndexToAbiType";
+export * from "./schemaToHex";
+export * from "./staticDataLength";

package/src/schemaIndexToAbiType.ts

@@ -0,0 +1,9 @@
+import { SchemaAbiType } from "@latticexyz/schema-type";
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,18 @@
+import { schemaAbiTypes } from "@latticexyz/schema-type";
+import { Hex } from "viem";
+import { Schema } from "./common";
+import { staticDataLength } from "./staticDataLength";
+
+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

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