@latticexyz/schema-type 2.0.0-alpha.1.26 → 2.0.0-alpha.1.261

package/src/typescript/{ArraySchemaType.ts → deprecated/types/ArraySchemaType.ts}

@@ -1,4 +1,4 @@
-import { SchemaType } from "./SchemaType.js";
+import { SchemaType } from "../SchemaType";
 
 export type ArraySchemaType =
   | SchemaType.UINT8_ARRAY

package/src/typescript/deprecated/types/DynamicSchemaType.ts

@@ -0,0 +1,4 @@
+import { SchemaType } from "../SchemaType";
+import { ArraySchemaType } from "./ArraySchemaType";
+
+export type DynamicSchemaType = ArraySchemaType | SchemaType.BYTES | SchemaType.STRING;

package/src/typescript/deprecated/types/StaticAbiTypes.ts

@@ -0,0 +1,10 @@
+import { AbiTypes } from "./AbiTypes";
+import { AbiTypeToSchemaType } from "../mappings/AbiTypeToSchemaType";
+import { getStaticByteLength } from "../utils/getStaticByteLength";
+import { SchemaTypeToAbiType } from "../mappings/SchemaTypeToAbiType";
+import { StaticSchemaType } from "./StaticSchemaType";
+
+export type StaticAbiType = (typeof SchemaTypeToAbiType)[StaticSchemaType];
+export const StaticAbiTypes = AbiTypes.filter(
+  (abiType) => getStaticByteLength(AbiTypeToSchemaType[abiType]) > 0
+) as StaticAbiType[];

package/src/typescript/deprecated/types/StaticArray.ts

@@ -0,0 +1,3 @@
+import { StaticAbiType } from "./StaticAbiTypes";
+
+export type StaticArray = `${StaticAbiType}[${number}]`;

package/src/typescript/deprecated/types/StaticSchemaType.ts

@@ -0,0 +1,4 @@
+import { SchemaType } from "../SchemaType";
+import { DynamicSchemaType } from "./DynamicSchemaType";
+
+export type StaticSchemaType = Exclude<SchemaType, DynamicSchemaType>;

package/src/typescript/deprecated/types/index.ts

@@ -0,0 +1,8 @@
+export type { AbiType } from "./AbiTypes";
+export { AbiTypes } from "./AbiTypes";
+export type { ArraySchemaType } from "./ArraySchemaType";
+export type { DynamicSchemaType } from "./DynamicSchemaType";
+export type { StaticAbiType } from "./StaticAbiTypes";
+export { StaticAbiTypes } from "./StaticAbiTypes";
+export type { StaticArray } from "./StaticArray";
+export type { StaticSchemaType } from "./StaticSchemaType";

package/src/typescript/{encodeSchema.ts → deprecated/utils/encodeSchema.ts}

@@ -1,5 +1,5 @@
-import { getStaticByteLength } from "./getStaticByteLength.js";
-import { SchemaType } from "./SchemaType.js";
+import { getStaticByteLength } from "./getStaticByteLength";
+import { SchemaType } from "../SchemaType";
 
 /**
  * Encode a table schema into a bytes32 hex string

package/src/typescript/deprecated/utils/getAbiTypeDefaultValue.ts

@@ -0,0 +1,11 @@
+import { AbiTypeToPrimitiveType } from "../mappings";
+import { AbiTypeToDefaultValue } from "../mappings/AbiTypeToDefaultValue";
+
+/**
+ * Return a value corresponding to the Solidity default value for a given abi type
+ */
+export function getAbiTypeDefaultValue<T extends string>(abiType: T) {
+  // Remove fixed array lengths (eg map uint256[10] to uint256[])
+  const normalizedType = abiType.replace(/(\w+)\[\d+\]/g, "$1[]");
+  return AbiTypeToDefaultValue[normalizedType as keyof typeof AbiTypeToDefaultValue] as AbiTypeToPrimitiveType<T>;
+}

package/src/typescript/{getStaticByteLength.ts → deprecated/utils/getStaticByteLength.ts}

@@ -1,4 +1,4 @@
-import { SchemaType } from "./SchemaType.js";
+import { SchemaType } from "../SchemaType";
 
 export function getStaticByteLength(schemaType: SchemaType) {
   const val = schemaType.valueOf();

package/src/typescript/deprecated/utils/index.ts

@@ -0,0 +1,3 @@
+export { encodeSchema } from "./encodeSchema";
+export { getStaticByteLength } from "./getStaticByteLength";
+export { getAbiTypeDefaultValue } from "./getAbiTypeDefaultValue";

package/src/typescript/dynamicAbiTypes.test-d.ts

@@ -0,0 +1,66 @@
+import { describe, expectTypeOf, it } from "vitest";
+import { Hex } from "viem";
+import { DynamicAbiTypeToPrimitiveType } from "./dynamicAbiTypes";
+
+describe("DynamicAbiTypeToPrimitiveType", () => {
+  it("maps uint8 array to number array", () => {
+    expectTypeOf<DynamicAbiTypeToPrimitiveType<"uint8[]">>().toMatchTypeOf<readonly number[]>();
+  });
+  it("maps uint32 array to number array", () => {
+    expectTypeOf<DynamicAbiTypeToPrimitiveType<"uint32[]">>().toMatchTypeOf<readonly number[]>();
+  });
+  it("maps uint48 array to number array", () => {
+    expectTypeOf<DynamicAbiTypeToPrimitiveType<"uint48[]">>().toMatchTypeOf<readonly number[]>();
+  });
+  it("maps uint56 array to bigint array", () => {
+    expectTypeOf<DynamicAbiTypeToPrimitiveType<"uint56[]">>().toMatchTypeOf<readonly bigint[]>();
+  });
+  it("maps uint256 array to bigint array", () => {
+    expectTypeOf<DynamicAbiTypeToPrimitiveType<"uint256[]">>().toMatchTypeOf<readonly bigint[]>();
+  });
+
+  it("maps int8 array to number array", () => {
+    expectTypeOf<DynamicAbiTypeToPrimitiveType<"int8[]">>().toMatchTypeOf<readonly number[]>();
+  });
+  it("maps int32 array to number array", () => {
+    expectTypeOf<DynamicAbiTypeToPrimitiveType<"int32[]">>().toMatchTypeOf<readonly number[]>();
+  });
+  it("maps int48 array to number array", () => {
+    expectTypeOf<DynamicAbiTypeToPrimitiveType<"int48[]">>().toMatchTypeOf<readonly number[]>();
+  });
+  it("maps int56 array to bigint array", () => {
+    expectTypeOf<DynamicAbiTypeToPrimitiveType<"int56[]">>().toMatchTypeOf<readonly bigint[]>();
+  });
+  it("maps int256 array to bigint array", () => {
+    expectTypeOf<DynamicAbiTypeToPrimitiveType<"int256[]">>().toMatchTypeOf<readonly bigint[]>();
+  });
+
+  it("maps bytes1 array to hex array", () => {
+    expectTypeOf<DynamicAbiTypeToPrimitiveType<"bytes1[]">>().toMatchTypeOf<readonly Hex[]>();
+  });
+  it("maps bytes2 array to hex array", () => {
+    expectTypeOf<DynamicAbiTypeToPrimitiveType<"bytes2[]">>().toMatchTypeOf<readonly Hex[]>();
+  });
+  it("maps bytes8 array to hex array", () => {
+    expectTypeOf<DynamicAbiTypeToPrimitiveType<"bytes8[]">>().toMatchTypeOf<readonly Hex[]>();
+  });
+  it("maps bytes32 array to hex array", () => {
+    expectTypeOf<DynamicAbiTypeToPrimitiveType<"bytes32[]">>().toMatchTypeOf<readonly Hex[]>();
+  });
+
+  it("maps bool array to boolean array", () => {
+    expectTypeOf<DynamicAbiTypeToPrimitiveType<"bool[]">>().toMatchTypeOf<readonly boolean[]>();
+  });
+
+  it("maps address array to hex array", () => {
+    expectTypeOf<DynamicAbiTypeToPrimitiveType<"address[]">>().toMatchTypeOf<readonly Hex[]>();
+  });
+
+  it("maps bytes to hex", () => {
+    expectTypeOf<DynamicAbiTypeToPrimitiveType<"bytes">>().toMatchTypeOf<Hex>();
+  });
+
+  it("maps string to string", () => {
+    expectTypeOf<DynamicAbiTypeToPrimitiveType<"string">>().toMatchTypeOf<string>();
+  });
+});

package/src/typescript/dynamicAbiTypes.ts

@@ -0,0 +1,124 @@
+import { Hex } from "viem";
+import { DynamicAbiType } from "./schemaAbiTypes";
+import { LiteralToBroad } from "./utils";
+
+// Variable-length ABI types, where their lengths are encoded by a PackedCounter within the record
+
+export type DynamicPrimitiveType =
+  | readonly number[]
+  | readonly bigint[]
+  | readonly Hex[]
+  | readonly boolean[]
+  | Hex
+  | string;
+
+export const dynamicAbiTypeToDefaultValue = {
+  "uint8[]": [] as readonly number[],
+  "uint16[]": [] as readonly number[],
+  "uint24[]": [] as readonly number[],
+  "uint32[]": [] as readonly number[],
+  "uint40[]": [] as readonly number[],
+  "uint48[]": [] as readonly number[],
+  "uint56[]": [] as readonly bigint[],
+  "uint64[]": [] as readonly bigint[],
+  "uint72[]": [] as readonly bigint[],
+  "uint80[]": [] as readonly bigint[],
+  "uint88[]": [] as readonly bigint[],
+  "uint96[]": [] as readonly bigint[],
+  "uint104[]": [] as readonly bigint[],
+  "uint112[]": [] as readonly bigint[],
+  "uint120[]": [] as readonly bigint[],
+  "uint128[]": [] as readonly bigint[],
+  "uint136[]": [] as readonly bigint[],
+  "uint144[]": [] as readonly bigint[],
+  "uint152[]": [] as readonly bigint[],
+  "uint160[]": [] as readonly bigint[],
+  "uint168[]": [] as readonly bigint[],
+  "uint176[]": [] as readonly bigint[],
+  "uint184[]": [] as readonly bigint[],
+  "uint192[]": [] as readonly bigint[],
+  "uint200[]": [] as readonly bigint[],
+  "uint208[]": [] as readonly bigint[],
+  "uint216[]": [] as readonly bigint[],
+  "uint224[]": [] as readonly bigint[],
+  "uint232[]": [] as readonly bigint[],
+  "uint240[]": [] as readonly bigint[],
+  "uint248[]": [] as readonly bigint[],
+  "uint256[]": [] as readonly bigint[],
+
+  "int8[]": [] as readonly number[],
+  "int16[]": [] as readonly number[],
+  "int24[]": [] as readonly number[],
+  "int32[]": [] as readonly number[],
+  "int40[]": [] as readonly number[],
+  "int48[]": [] as readonly number[],
+  "int56[]": [] as readonly bigint[],
+  "int64[]": [] as readonly bigint[],
+  "int72[]": [] as readonly bigint[],
+  "int80[]": [] as readonly bigint[],
+  "int88[]": [] as readonly bigint[],
+  "int96[]": [] as readonly bigint[],
+  "int104[]": [] as readonly bigint[],
+  "int112[]": [] as readonly bigint[],
+  "int120[]": [] as readonly bigint[],
+  "int128[]": [] as readonly bigint[],
+  "int136[]": [] as readonly bigint[],
+  "int144[]": [] as readonly bigint[],
+  "int152[]": [] as readonly bigint[],
+  "int160[]": [] as readonly bigint[],
+  "int168[]": [] as readonly bigint[],
+  "int176[]": [] as readonly bigint[],
+  "int184[]": [] as readonly bigint[],
+  "int192[]": [] as readonly bigint[],
+  "int200[]": [] as readonly bigint[],
+  "int208[]": [] as readonly bigint[],
+  "int216[]": [] as readonly bigint[],
+  "int224[]": [] as readonly bigint[],
+  "int232[]": [] as readonly bigint[],
+  "int240[]": [] as readonly bigint[],
+  "int248[]": [] as readonly bigint[],
+  "int256[]": [] as readonly bigint[],
+
+  "bytes1[]": [] as readonly Hex[],
+  "bytes2[]": [] as readonly Hex[],
+  "bytes3[]": [] as readonly Hex[],
+  "bytes4[]": [] as readonly Hex[],
+  "bytes5[]": [] as readonly Hex[],
+  "bytes6[]": [] as readonly Hex[],
+  "bytes7[]": [] as readonly Hex[],
+  "bytes8[]": [] as readonly Hex[],
+  "bytes9[]": [] as readonly Hex[],
+  "bytes10[]": [] as readonly Hex[],
+  "bytes11[]": [] as readonly Hex[],
+  "bytes12[]": [] as readonly Hex[],
+  "bytes13[]": [] as readonly Hex[],
+  "bytes14[]": [] as readonly Hex[],
+  "bytes15[]": [] as readonly Hex[],
+  "bytes16[]": [] as readonly Hex[],
+  "bytes17[]": [] as readonly Hex[],
+  "bytes18[]": [] as readonly Hex[],
+  "bytes19[]": [] as readonly Hex[],
+  "bytes20[]": [] as readonly Hex[],
+  "bytes21[]": [] as readonly Hex[],
+  "bytes22[]": [] as readonly Hex[],
+  "bytes23[]": [] as readonly Hex[],
+  "bytes24[]": [] as readonly Hex[],
+  "bytes25[]": [] as readonly Hex[],
+  "bytes26[]": [] as readonly Hex[],
+  "bytes27[]": [] as readonly Hex[],
+  "bytes28[]": [] as readonly Hex[],
+  "bytes29[]": [] as readonly Hex[],
+  "bytes30[]": [] as readonly Hex[],
+  "bytes31[]": [] as readonly Hex[],
+  "bytes32[]": [] as readonly Hex[],
+
+  "bool[]": [] as readonly boolean[],
+  "address[]": [] as readonly Hex[],
+
+  bytes: "0x",
+  string: "",
+} as const satisfies Record<DynamicAbiType, DynamicPrimitiveType>;
+
+export type DynamicAbiTypeToPrimitiveType<TDynamicAbiType extends DynamicAbiType = DynamicAbiType> = LiteralToBroad<
+  (typeof dynamicAbiTypeToDefaultValue)[TDynamicAbiType]
+>;

package/src/typescript/index.ts

@@ -1,15 +1,6 @@
-export type { StaticSchemaType } from "./StaticSchemaType.js";
-export type { DynamicSchemaType } from "./DynamicSchemaType.js";
-export type { ArraySchemaType } from "./ArraySchemaType.js";
-export type { SchemaTypeToPrimitive } from "./SchemaTypeToPrimitive.js";
-export type { AbiType } from "./AbiTypes.js";
-export type { StaticAbiType } from "./StaticAbiTypes.js";
-
-export { SchemaType } from "./SchemaType.js";
-export { encodeSchema } from "./encodeSchema.js";
-export { getStaticByteLength } from "./getStaticByteLength.js";
-export { SchemaTypeArrayToElement } from "./SchemaTypeArrayToElement.js";
-export { SchemaTypeToAbiType } from "./SchemaTypeToAbiType.js";
-export { AbiTypeToSchemaType } from "./AbiTypeToSchemaType.js";
-export { AbiTypes } from "./AbiTypes.js";
-export { StaticAbiTypes } from "./StaticAbiTypes.js";
+export * from "./arrayAbiTypes";
+export * from "./dynamicAbiTypes";
+export * from "./schemaAbiTypes";
+export * from "./schemaAbiTypeToDefaultValue";
+export * from "./staticAbiTypes";
+export * from "./schemaAbiTypeToPrimitiveType";

package/src/typescript/schemaAbiTypeToDefaultValue.ts

@@ -0,0 +1,8 @@
+import { SchemaAbiType } from "./schemaAbiTypes";
+import { DynamicAbiTypeToPrimitiveType, dynamicAbiTypeToDefaultValue } from "./dynamicAbiTypes";
+import { StaticAbiTypeToPrimitiveType, staticAbiTypeToDefaultValue } from "./staticAbiTypes";
+
+export const schemaAbiTypeToDefaultValue = {
+  ...staticAbiTypeToDefaultValue,
+  ...dynamicAbiTypeToDefaultValue,
+} as const satisfies Record<SchemaAbiType, StaticAbiTypeToPrimitiveType | DynamicAbiTypeToPrimitiveType>;

package/src/typescript/schemaAbiTypeToPrimitiveType.ts

@@ -0,0 +1,7 @@
+import { schemaAbiTypeToDefaultValue } from "./schemaAbiTypeToDefaultValue";
+import { SchemaAbiType } from "./schemaAbiTypes";
+import { LiteralToBroad } from "./utils";
+
+export type SchemaAbiTypeToPrimitiveType<T extends SchemaAbiType> = LiteralToBroad<
+  (typeof schemaAbiTypeToDefaultValue)[T]
+>;

package/src/typescript/schemaAbiTypes.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from "vitest";
+import fs from "node:fs/promises";
+import { schemaAbiTypes } from "./schemaAbiTypes";
+
+describe("schemaAbiTypes", () => {
+  it("should be in sync with SchemaType.sol", async () => {
+    const source = await fs.readFile(`${__dirname}/../solidity/SchemaType.sol`, "utf8");
+    const matches = source.match(/enum SchemaType \{([\s\S]+?)\}/);
+    const soliditySchemaTypes = matches?.[1].replace(/\s/g, "").split(",") ?? [];
+
+    const soliditySchemaTypesAsAbiTypes = soliditySchemaTypes.map((soliditySchemaType) =>
+      soliditySchemaType.replace(/_ARRAY$/, "[]").toLowerCase()
+    );
+
+    expect(soliditySchemaTypesAsAbiTypes).toStrictEqual(schemaAbiTypes);
+  });
+});

package/src/typescript/schemaAbiTypes.ts

@@ -0,0 +1,213 @@
+import { AbiType } from "abitype";
+import { TupleSplit } from "./utils";
+
+// Keep this array in sync with SchemaType.sol enum
+export const schemaAbiTypes = [
+  "uint8",
+  "uint16",
+  "uint24",
+  "uint32",
+  "uint40",
+  "uint48",
+  "uint56",
+  "uint64",
+  "uint72",
+  "uint80",
+  "uint88",
+  "uint96",
+  "uint104",
+  "uint112",
+  "uint120",
+  "uint128",
+  "uint136",
+  "uint144",
+  "uint152",
+  "uint160",
+  "uint168",
+  "uint176",
+  "uint184",
+  "uint192",
+  "uint200",
+  "uint208",
+  "uint216",
+  "uint224",
+  "uint232",
+  "uint240",
+  "uint248",
+  "uint256",
+  "int8",
+  "int16",
+  "int24",
+  "int32",
+  "int40",
+  "int48",
+  "int56",
+  "int64",
+  "int72",
+  "int80",
+  "int88",
+  "int96",
+  "int104",
+  "int112",
+  "int120",
+  "int128",
+  "int136",
+  "int144",
+  "int152",
+  "int160",
+  "int168",
+  "int176",
+  "int184",
+  "int192",
+  "int200",
+  "int208",
+  "int216",
+  "int224",
+  "int232",
+  "int240",
+  "int248",
+  "int256",
+  "bytes1",
+  "bytes2",
+  "bytes3",
+  "bytes4",
+  "bytes5",
+  "bytes6",
+  "bytes7",
+  "bytes8",
+  "bytes9",
+  "bytes10",
+  "bytes11",
+  "bytes12",
+  "bytes13",
+  "bytes14",
+  "bytes15",
+  "bytes16",
+  "bytes17",
+  "bytes18",
+  "bytes19",
+  "bytes20",
+  "bytes21",
+  "bytes22",
+  "bytes23",
+  "bytes24",
+  "bytes25",
+  "bytes26",
+  "bytes27",
+  "bytes28",
+  "bytes29",
+  "bytes30",
+  "bytes31",
+  "bytes32",
+  "bool",
+  "address",
+  "uint8[]",
+  "uint16[]",
+  "uint24[]",
+  "uint32[]",
+  "uint40[]",
+  "uint48[]",
+  "uint56[]",
+  "uint64[]",
+  "uint72[]",
+  "uint80[]",
+  "uint88[]",
+  "uint96[]",
+  "uint104[]",
+  "uint112[]",
+  "uint120[]",
+  "uint128[]",
+  "uint136[]",
+  "uint144[]",
+  "uint152[]",
+  "uint160[]",
+  "uint168[]",
+  "uint176[]",
+  "uint184[]",
+  "uint192[]",
+  "uint200[]",
+  "uint208[]",
+  "uint216[]",
+  "uint224[]",
+  "uint232[]",
+  "uint240[]",
+  "uint248[]",
+  "uint256[]",
+  "int8[]",
+  "int16[]",
+  "int24[]",
+  "int32[]",
+  "int40[]",
+  "int48[]",
+  "int56[]",
+  "int64[]",
+  "int72[]",
+  "int80[]",
+  "int88[]",
+  "int96[]",
+  "int104[]",
+  "int112[]",
+  "int120[]",
+  "int128[]",
+  "int136[]",
+  "int144[]",
+  "int152[]",
+  "int160[]",
+  "int168[]",
+  "int176[]",
+  "int184[]",
+  "int192[]",
+  "int200[]",
+  "int208[]",
+  "int216[]",
+  "int224[]",
+  "int232[]",
+  "int240[]",
+  "int248[]",
+  "int256[]",
+  "bytes1[]",
+  "bytes2[]",
+  "bytes3[]",
+  "bytes4[]",
+  "bytes5[]",
+  "bytes6[]",
+  "bytes7[]",
+  "bytes8[]",
+  "bytes9[]",
+  "bytes10[]",
+  "bytes11[]",
+  "bytes12[]",
+  "bytes13[]",
+  "bytes14[]",
+  "bytes15[]",
+  "bytes16[]",
+  "bytes17[]",
+  "bytes18[]",
+  "bytes19[]",
+  "bytes20[]",
+  "bytes21[]",
+  "bytes22[]",
+  "bytes23[]",
+  "bytes24[]",
+  "bytes25[]",
+  "bytes26[]",
+  "bytes27[]",
+  "bytes28[]",
+  "bytes29[]",
+  "bytes30[]",
+  "bytes31[]",
+  "bytes32[]",
+  "bool[]",
+  "address[]",
+  "bytes",
+  "string",
+] as const satisfies readonly AbiType[];
+
+export type SchemaAbiType = (typeof schemaAbiTypes)[number];
+
+// These are defined here to keep the index position (98) consolidated, since we use it both in runtime code and type definition
+export const staticAbiTypes = schemaAbiTypes.slice(0, 98) as any as TupleSplit<typeof schemaAbiTypes, 98>[0];
+export const dynamicAbiTypes = schemaAbiTypes.slice(98) as any as TupleSplit<typeof schemaAbiTypes, 98>[1];
+
+export type StaticAbiType = (typeof staticAbiTypes)[number];
+export type DynamicAbiType = (typeof dynamicAbiTypes)[number];

package/src/typescript/staticAbiTypes.test-d.ts

@@ -0,0 +1,58 @@
+import { describe, expectTypeOf, it } from "vitest";
+import { Hex } from "viem";
+import { StaticAbiTypeToPrimitiveType } from "./staticAbiTypes";
+
+describe("StaticAbiTypeToPrimitiveType", () => {
+  it("maps uint8 to number", () => {
+    expectTypeOf<StaticAbiTypeToPrimitiveType<"uint8">>().toBeNumber();
+  });
+  it("maps uint32 to number", () => {
+    expectTypeOf<StaticAbiTypeToPrimitiveType<"uint32">>().toBeNumber();
+  });
+  it("maps uint48 to number", () => {
+    expectTypeOf<StaticAbiTypeToPrimitiveType<"uint48">>().toBeNumber();
+  });
+  it("maps uint56 to number", () => {
+    expectTypeOf<StaticAbiTypeToPrimitiveType<"uint56">>().toMatchTypeOf<bigint>();
+  });
+  it("maps uint256 to number", () => {
+    expectTypeOf<StaticAbiTypeToPrimitiveType<"uint256">>().toMatchTypeOf<bigint>();
+  });
+
+  it("maps int8 to number", () => {
+    expectTypeOf<StaticAbiTypeToPrimitiveType<"int8">>().toBeNumber();
+  });
+  it("maps int32 to number", () => {
+    expectTypeOf<StaticAbiTypeToPrimitiveType<"int32">>().toBeNumber();
+  });
+  it("maps int48 to number", () => {
+    expectTypeOf<StaticAbiTypeToPrimitiveType<"int48">>().toBeNumber();
+  });
+  it("maps int56 to number", () => {
+    expectTypeOf<StaticAbiTypeToPrimitiveType<"int56">>().toMatchTypeOf<bigint>();
+  });
+  it("maps int256 to number", () => {
+    expectTypeOf<StaticAbiTypeToPrimitiveType<"int256">>().toMatchTypeOf<bigint>();
+  });
+
+  it("maps bytes1 to hex", () => {
+    expectTypeOf<StaticAbiTypeToPrimitiveType<"bytes1">>().toMatchTypeOf<Hex>();
+  });
+  it("maps bytes2 to hex", () => {
+    expectTypeOf<StaticAbiTypeToPrimitiveType<"bytes2">>().toMatchTypeOf<Hex>();
+  });
+  it("maps bytes8 to hex", () => {
+    expectTypeOf<StaticAbiTypeToPrimitiveType<"bytes8">>().toMatchTypeOf<Hex>();
+  });
+  it("maps bytes32 to hex", () => {
+    expectTypeOf<StaticAbiTypeToPrimitiveType<"bytes32">>().toMatchTypeOf<Hex>();
+  });
+
+  it("maps bool to boolean", () => {
+    expectTypeOf<StaticAbiTypeToPrimitiveType<"bool">>().toBeBoolean();
+  });
+
+  it("maps address to hex", () => {
+    expectTypeOf<StaticAbiTypeToPrimitiveType<"address">>().toMatchTypeOf<Hex>();
+  });
+});