@latticexyz/protocol-parser 2.0.0-next.17 → 2.0.0-next.18

package/src/decodeValueArgs.ts

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

package/src/encodeField.ts

@@ -1,19 +1,19 @@
-import { SchemaAbiType, arrayAbiTypeToStaticAbiType, isArrayAbiType } from "@latticexyz/schema-type";
+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 }>
+  value: AbiParameterToPrimitiveType<{ type: TSchemaAbiType }>,
 ): Hex {
   if (isArrayAbiType(fieldType) && Array.isArray(value)) {
-    const staticFieldType = arrayAbiTypeToStaticAbiType(fieldType);
+    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
+          value,
         );
   }
   return encodePacked([fieldType], [value]);

package/src/encodeKey.ts

@@ -1,4 +1,4 @@
-import { isStaticAbiType } from "@latticexyz/schema-type";
+import { isStaticAbiType } from "@latticexyz/schema-type/internal";
 import { Hex } from "viem";
 import { SchemaToPrimitives, KeySchema } from "./common";
 import { encodeKeyTuple } from "./encodeKeyTuple";

package/src/encodeKeyTuple.test.ts

@@ -12,8 +12,8 @@ describe("encodeKeyTuple", () => {
           staticFields: ["bool"],
           dynamicFields: [],
         },
-        [true]
-      )
+        [true],
+      ),
     ).toStrictEqual(["0x0000000000000000000000000000000000000000000000000000000000000001"]);
   });
 
@@ -26,7 +26,7 @@ describe("encodeKeyTuple", () => {
         "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF",
         true,
         3,
-      ])
+      ]),
     ).toStrictEqual([
       "0x000000000000000000000000000000000000000000000000000000000000002a",
       "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd6",

package/src/encodeKeyTuple.ts

@@ -1,4 +1,4 @@
-import { StaticPrimitiveType } from "@latticexyz/schema-type";
+import { StaticPrimitiveType } from "@latticexyz/schema-type/internal";
 import { Hex, encodeAbiParameters } from "viem";
 import { Schema } from "./common";
 

package/src/encodeLengths.test.ts

@@ -4,13 +4,13 @@ import { encodeLengths } from "./encodeLengths";
 describe("encodeLengths", () => {
   it("can encode empty tuple", () => {
     expect(encodeLengths([])).toMatchInlineSnapshot(
-      '"0x0000000000000000000000000000000000000000000000000000000000000000"'
+      '"0x0000000000000000000000000000000000000000000000000000000000000000"',
     );
   });
 
   it("can encode bool key tuple", () => {
     expect(encodeLengths(["0x1234", "0x12345678"])).toMatchInlineSnapshot(
-      '"0x0000000000000000000000000000000000000004000000000200000000000006"'
+      '"0x0000000000000000000000000000000000000004000000000200000000000006"',
     );
   });
 });

package/src/encodeLengths.ts

@@ -7,6 +7,6 @@ export function encodeLengths(values: Hex[]): Hex {
 
   return padHex(
     concatHex([...byteLengths.map((length) => encodeField("uint40", length)), encodeField("uint56", totalByteLength)]),
-    { size: 32, dir: "left" }
+    { size: 32, dir: "left" },
   );
 }

package/src/encodeRecord.test.ts

@@ -6,7 +6,7 @@ describe("encodeRecord", () => {
     const valueSchema = { staticFields: ["uint32", "uint128"], dynamicFields: ["uint32[]", "string"] } as const;
     const hex = encodeRecord(valueSchema, [1, 2n, [3, 4], "some string"]);
     expect(hex).toBe(
-      "0x0000000100000000000000000000000000000002000000000000000000000000000000000000000b0000000008000000000000130000000300000004736f6d6520737472696e67"
+      "0x0000000100000000000000000000000000000002000000000000000000000000000000000000000b0000000008000000000000130000000300000004736f6d6520737472696e67",
     );
   });
 

package/src/encodeRecord.ts

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

package/src/encodeValue.ts

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

package/src/encodeValueArgs.ts

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

package/src/errors.ts

@@ -1,6 +1,6 @@
 import { Hex } from "viem";
 import { MUDError } from "@latticexyz/common/errors";
-import { StaticAbiType, staticAbiTypeToByteLength } from "@latticexyz/schema-type";
+import { StaticAbiType, staticAbiTypeToByteLength } from "@latticexyz/schema-type/internal";
 
 export class InvalidHexLengthError extends MUDError {
   override name = "InvalidHexValueError";
@@ -16,10 +16,10 @@ export class InvalidHexLengthForSchemaError extends MUDError {
   }
 }
 
-export class InvalidHexLengthForPackedCounterError extends MUDError {
-  override name = "InvalidHexLengthForPackedCounterError";
+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 a packed counter.`);
+    super(`Hex value "${value}" has length of ${value.length - 2}, but expected length of 64 for encoded lengths.`);
   }
 }
 
@@ -29,7 +29,7 @@ export class InvalidHexLengthForStaticFieldError extends MUDError {
     super(
       `Hex value "${value}" has length of ${value.length - 2}, but expected length of ${
         staticAbiTypeToByteLength[abiType] * 2
-      } for ${abiType} type.`
+      } for ${abiType} type.`,
     );
   }
 }
@@ -40,7 +40,7 @@ export class InvalidHexLengthForArrayFieldError extends MUDError {
     super(
       `Hex value "${value}" has length of ${value.length - 2}, but expected a multiple of ${
         staticAbiTypeToByteLength[abiType] * 2
-      } for ${abiType}[] type.`
+      } for ${abiType}[] type.`,
     );
   }
 }
@@ -50,16 +50,16 @@ export class SchemaStaticLengthMismatchError extends MUDError {
   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?`
+        `Is \`staticAbiTypeToByteLength\` up to date with Solidity schema types?`,
     );
   }
 }
 
-export class PackedCounterLengthMismatchError extends MUDError {
-  override name = "PackedCounterLengthMismatchError";
-  constructor(packedCounterData: Hex, definedLength: bigint, summedLength: bigint) {
+export class EncodedLengthsLengthMismatchError extends MUDError {
+  override name = "EncodedLengthsLengthMismatchError";
+  constructor(encodedLengthsData: Hex, definedLength: bigint, summedLength: bigint) {
     super(
-      `PackedCounter "${packedCounterData}" total bytes length (${definedLength}) did not match the summed length of all field byte lengths (${summedLength}).`
+      `EncodedLengths "${encodedLengthsData}" total bytes length (${definedLength}) did not match the summed length of all field byte lengths (${summedLength}).`,
     );
   }
 }

package/src/exports/index.ts

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

package/src/exports/internal.ts

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

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

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

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

@@ -0,0 +1,35 @@
+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/{hexToPackedCounter.ts → hexToEncodedLengths.ts}

@@ -1,22 +1,22 @@
 import { Hex } from "viem";
 import { decodeStaticField } from "./decodeStaticField";
 import { decodeDynamicField } from "./decodeDynamicField";
-import { InvalidHexLengthForPackedCounterError, PackedCounterLengthMismatchError } from "./errors";
+import { InvalidHexLengthForEncodedLengthsError, EncodedLengthsLengthMismatchError } from "./errors";
 import { readHex } from "@latticexyz/common";
 
-// Keep this logic in sync with PackedCounter.sol
+// 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 hexToPackedCounter(data: Hex): {
+export function hexToEncodedLengths(data: Hex): {
   totalByteLength: bigint;
   fieldByteLengths: readonly number[];
 } {
   if (data.length !== 66) {
-    throw new InvalidHexLengthForPackedCounterError(data);
+    throw new InvalidHexLengthForEncodedLengthsError(data);
   }
 
   const totalByteLength = decodeStaticField("uint56", readHex(data, 32 - 7, 32));
@@ -27,7 +27,7 @@ export function hexToPackedCounter(data: Hex): {
 
   const summedLength = BigInt(fieldByteLengths.reduce((total, length) => total + length, 0));
   if (summedLength !== totalByteLength) {
-    throw new PackedCounterLengthMismatchError(data, totalByteLength, summedLength);
+    throw new EncodedLengthsLengthMismatchError(data, totalByteLength, summedLength);
   }
 
   return { totalByteLength, fieldByteLengths };

package/src/hexToSchema.test.ts

@@ -55,14 +55,14 @@ describe("hexToSchema", () => {
 
   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.'
+      '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?'
+      '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,4 +1,9 @@
-import { StaticAbiType, DynamicAbiType, schemaAbiTypes, staticAbiTypeToByteLength } from "@latticexyz/schema-type";
+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";
@@ -28,7 +33,7 @@ export function hexToSchema(data: Hex): Schema {
   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?`
+        `Is \`staticAbiTypeToByteLength\` up to date with Solidity schema types?`,
     );
     throw new SchemaStaticLengthMismatchError(data, staticDataLength, actualStaticDataLength);
   }

package/src/keySchemaToHex.ts

@@ -1,4 +1,4 @@
-import { isStaticAbiType } from "@latticexyz/schema-type";
+import { isStaticAbiType } from "@latticexyz/schema-type/internal";
 import { Hex } from "viem";
 import { KeySchema } from "./common";
 import { schemaToHex } from "./schemaToHex";

package/src/schemaIndexToAbiType.ts

@@ -1,4 +1,4 @@
-import { SchemaAbiType } from "@latticexyz/schema-type";
+import { SchemaAbiType } from "@latticexyz/schema-type/internal";
 import { Schema } from "./common";
 
 export function schemaIndexToAbiType(schema: Schema, schemaIndex: number): SchemaAbiType {

package/src/schemaToHex.test.ts

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

package/src/schemaToHex.ts

@@ -1,4 +1,4 @@
-import { schemaAbiTypes } from "@latticexyz/schema-type";
+import { schemaAbiTypes } from "@latticexyz/schema-type/internal";
 import { Hex } from "viem";
 import { Schema } from "./common";
 import { staticDataLength } from "./staticDataLength";

package/src/staticDataLength.ts

@@ -1,4 +1,4 @@
-import { StaticAbiType, staticAbiTypeToByteLength } from "@latticexyz/schema-type";
+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,6 +1,6 @@
 import { Hex } from "viem";
 import { ValueSchema } from "./common";
-import { isDynamicAbiType, isStaticAbiType, staticAbiTypeToByteLength } from "@latticexyz/schema-type";
+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 {

package/src/valueSchemaToHex.ts

@@ -1,4 +1,4 @@
-import { isDynamicAbiType, isStaticAbiType } from "@latticexyz/schema-type";
+import { isDynamicAbiType, isStaticAbiType } from "@latticexyz/schema-type/internal";
 import { Hex } from "viem";
 import { ValueSchema } from "./common";
 import { schemaToHex } from "./schemaToHex";

package/src/hexToPackedCounter.test.ts

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

package/src/index.ts

@@ -1,27 +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 "./hexToPackedCounter";
-export * from "./hexToSchema";
-export * from "./hexToTableSchema";
-export * from "./keySchemaToHex";
-export * from "./schemaIndexToAbiType";
-export * from "./schemaToHex";
-export * from "./staticDataLength";
-export * from "./valueSchemaToFieldLayoutHex";
-export * from "./valueSchemaToHex";