@latticexyz/protocol-parser 0.0.0-main-20230705225731

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,11 @@
+export * from "./common";
+export * from "./decodeDynamicField";
+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 "./hexToTableSchema";

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);
+}