@latticexyz/schema-type 2.0.12-type-resolutions-effc7ab1 → 2.0.12-type-resolutions-8538f80e

package/src/typescript/exports/internal.ts

@@ -0,0 +1,6 @@
+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,219 @@
+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
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const staticAbiTypes = schemaAbiTypes.slice(0, 98) as any as TupleSplit<typeof schemaAbiTypes, 98>[0];
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+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];
+
+export function isSchemaAbiType(abiType: unknown): abiType is SchemaAbiType {
+  return schemaAbiTypes.includes(abiType as SchemaAbiType);
+}

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

package/src/typescript/staticAbiTypes.ts

@@ -0,0 +1,223 @@
+import { Hex } from "viem";
+import { StaticAbiType, staticAbiTypes } from "./schemaAbiTypes";
+import { LiteralToBroad } from "./utils";
+
+// Fixed-length ABI types
+
+export type StaticPrimitiveType = number | bigint | boolean | Hex;
+
+export const staticAbiTypeToDefaultValue = {
+  uint8: 0,
+  uint16: 0,
+  uint24: 0,
+  uint32: 0,
+  uint40: 0,
+  uint48: 0,
+  uint56: 0n,
+  uint64: 0n,
+  uint72: 0n,
+  uint80: 0n,
+  uint88: 0n,
+  uint96: 0n,
+  uint104: 0n,
+  uint112: 0n,
+  uint120: 0n,
+  uint128: 0n,
+  uint136: 0n,
+  uint144: 0n,
+  uint152: 0n,
+  uint160: 0n,
+  uint168: 0n,
+  uint176: 0n,
+  uint184: 0n,
+  uint192: 0n,
+  uint200: 0n,
+  uint208: 0n,
+  uint216: 0n,
+  uint224: 0n,
+  uint232: 0n,
+  uint240: 0n,
+  uint248: 0n,
+  uint256: 0n,
+
+  int8: 0,
+  int16: 0,
+  int24: 0,
+  int32: 0,
+  int40: 0,
+  int48: 0,
+  int56: 0n,
+  int64: 0n,
+  int72: 0n,
+  int80: 0n,
+  int88: 0n,
+  int96: 0n,
+  int104: 0n,
+  int112: 0n,
+  int120: 0n,
+  int128: 0n,
+  int136: 0n,
+  int144: 0n,
+  int152: 0n,
+  int160: 0n,
+  int168: 0n,
+  int176: 0n,
+  int184: 0n,
+  int192: 0n,
+  int200: 0n,
+  int208: 0n,
+  int216: 0n,
+  int224: 0n,
+  int232: 0n,
+  int240: 0n,
+  int248: 0n,
+  int256: 0n,
+
+  bytes1: "0x00",
+  bytes2: "0x0000",
+  bytes3: "0x000000",
+  bytes4: "0x00000000",
+  bytes5: "0x0000000000",
+  bytes6: "0x000000000000",
+  bytes7: "0x00000000000000",
+  bytes8: "0x0000000000000000",
+  bytes9: "0x000000000000000000",
+  bytes10: "0x00000000000000000000",
+  bytes11: "0x0000000000000000000000",
+  bytes12: "0x000000000000000000000000",
+  bytes13: "0x00000000000000000000000000",
+  bytes14: "0x0000000000000000000000000000",
+  bytes15: "0x000000000000000000000000000000",
+  bytes16: "0x00000000000000000000000000000000",
+  bytes17: "0x0000000000000000000000000000000000",
+  bytes18: "0x000000000000000000000000000000000000",
+  bytes19: "0x00000000000000000000000000000000000000",
+  bytes20: "0x0000000000000000000000000000000000000000",
+  bytes21: "0x000000000000000000000000000000000000000000",
+  bytes22: "0x00000000000000000000000000000000000000000000",
+  bytes23: "0x0000000000000000000000000000000000000000000000",
+  bytes24: "0x000000000000000000000000000000000000000000000000",
+  bytes25: "0x00000000000000000000000000000000000000000000000000",
+  bytes26: "0x0000000000000000000000000000000000000000000000000000",
+  bytes27: "0x000000000000000000000000000000000000000000000000000000",
+  bytes28: "0x00000000000000000000000000000000000000000000000000000000",
+  bytes29: "0x0000000000000000000000000000000000000000000000000000000000",
+  bytes30: "0x000000000000000000000000000000000000000000000000000000000000",
+  bytes31: "0x00000000000000000000000000000000000000000000000000000000000000",
+  bytes32: "0x0000000000000000000000000000000000000000000000000000000000000000",
+
+  bool: false,
+  address: "0x0000000000000000000000000000000000000000",
+} as const satisfies Record<StaticAbiType, StaticPrimitiveType>;
+
+export type StaticAbiTypeToPrimitiveType<TStaticAbiType extends StaticAbiType = StaticAbiType> = LiteralToBroad<
+  (typeof staticAbiTypeToDefaultValue)[TStaticAbiType]
+>;
+
+export const staticAbiTypeToByteLength = {
+  uint8: 1,
+  uint16: 2,
+  uint24: 3,
+  uint32: 4,
+  uint40: 5,
+  uint48: 6,
+  uint56: 7,
+  uint64: 8,
+  uint72: 9,
+  uint80: 10,
+  uint88: 11,
+  uint96: 12,
+  uint104: 13,
+  uint112: 14,
+  uint120: 15,
+  uint128: 16,
+  uint136: 17,
+  uint144: 18,
+  uint152: 19,
+  uint160: 20,
+  uint168: 21,
+  uint176: 22,
+  uint184: 23,
+  uint192: 24,
+  uint200: 25,
+  uint208: 26,
+  uint216: 27,
+  uint224: 28,
+  uint232: 29,
+  uint240: 30,
+  uint248: 31,
+  uint256: 32,
+
+  int8: 1,
+  int16: 2,
+  int24: 3,
+  int32: 4,
+  int40: 5,
+  int48: 6,
+  int56: 7,
+  int64: 8,
+  int72: 9,
+  int80: 10,
+  int88: 11,
+  int96: 12,
+  int104: 13,
+  int112: 14,
+  int120: 15,
+  int128: 16,
+  int136: 17,
+  int144: 18,
+  int152: 19,
+  int160: 20,
+  int168: 21,
+  int176: 22,
+  int184: 23,
+  int192: 24,
+  int200: 25,
+  int208: 26,
+  int216: 27,
+  int224: 28,
+  int232: 29,
+  int240: 30,
+  int248: 31,
+  int256: 32,
+
+  bytes1: 1,
+  bytes2: 2,
+  bytes3: 3,
+  bytes4: 4,
+  bytes5: 5,
+  bytes6: 6,
+  bytes7: 7,
+  bytes8: 8,
+  bytes9: 9,
+  bytes10: 10,
+  bytes11: 11,
+  bytes12: 12,
+  bytes13: 13,
+  bytes14: 14,
+  bytes15: 15,
+  bytes16: 16,
+  bytes17: 17,
+  bytes18: 18,
+  bytes19: 19,
+  bytes20: 20,
+  bytes21: 21,
+  bytes22: 22,
+  bytes23: 23,
+  bytes24: 24,
+  bytes25: 25,
+  bytes26: 26,
+  bytes27: 27,
+  bytes28: 28,
+  bytes29: 29,
+  bytes30: 30,
+  bytes31: 31,
+  bytes32: 32,
+
+  bool: 1,
+  address: 20,
+} as const satisfies Record<StaticAbiType, number>;
+
+export function isStaticAbiType(abiType: unknown): abiType is StaticAbiType {
+  return staticAbiTypes.includes(abiType as StaticAbiType);
+}

package/src/typescript/utils.ts

@@ -0,0 +1,25 @@
+import { Hex } from "viem";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type TupleSplit<T, N extends number, O extends readonly any[] = readonly []> = O["length"] extends N
+  ? [O, T]
+  : T extends readonly [infer F, ...infer R]
+    ? TupleSplit<readonly [...R], N, readonly [...O, F]>
+    : [O, T];
+
+export type LiteralToBroad<T> =
+  T extends Readonly<Array<infer Element>>
+    ? readonly LiteralToBroad<Element>[]
+    : T extends Array<infer Element>
+      ? LiteralToBroad<Element>[]
+      : T extends number
+        ? number
+        : T extends bigint
+          ? bigint
+          : T extends Hex
+            ? Hex
+            : T extends boolean
+              ? boolean
+              : T extends string
+                ? string
+                : never;