@latticexyz/protocol-parser 2.0.0-alpha.1.222

package/src/decodeDynamicField.ts

@@ -0,0 +1,141 @@
+import { Hex, hexToString, sliceHex } from "viem";
+import { DynamicAbiType, DynamicAbiTypeToPrimitiveType, arrayAbiTypeToStaticAbiType } from "./dynamicAbiTypes";
+import { assertExhaustive } from "./assertExhaustive";
+import { staticAbiTypeToByteLength } from "./staticAbiTypes";
+import { decodeStaticField } from "./decodeStaticField";
+import { InvalidHexLengthError, InvalidHexLengthForArrayFieldError } from "./errors";
+
+// TODO: require size/length for dynamic fields, because hex might be longer (sometimes we just move the length pointer of arrays without updating the value)
+//       this means the error should probably change from "invalid length" to "too short", which viem has that we could reuse?
+
+export function decodeDynamicField<
+  TAbiType extends DynamicAbiType,
+  TPrimitiveType extends DynamicAbiTypeToPrimitiveType<TAbiType>
+>(abiType: TAbiType, data: Hex): TPrimitiveType {
+  if (abiType === "bytes") {
+    return data as TPrimitiveType;
+  }
+  if (abiType === "string") {
+    return hexToString(data) as TPrimitiveType;
+  }
+
+  if (data.length > 3 && data.length % 2 !== 0) {
+    throw new InvalidHexLengthError(data);
+  }
+
+  const dataSize = (data.length - 2) / 2;
+
+  switch (abiType) {
+    case "uint8[]":
+    case "uint16[]":
+    case "uint24[]":
+    case "uint32[]":
+    case "uint40[]":
+    case "uint48[]":
+    case "uint56[]":
+    case "uint64[]":
+    case "uint72[]":
+    case "uint80[]":
+    case "uint88[]":
+    case "uint96[]":
+    case "uint104[]":
+    case "uint112[]":
+    case "uint120[]":
+    case "uint128[]":
+    case "uint136[]":
+    case "uint144[]":
+    case "uint152[]":
+    case "uint160[]":
+    case "uint168[]":
+    case "uint176[]":
+    case "uint184[]":
+    case "uint192[]":
+    case "uint200[]":
+    case "uint208[]":
+    case "uint216[]":
+    case "uint224[]":
+    case "uint232[]":
+    case "uint240[]":
+    case "uint248[]":
+    case "uint256[]":
+    case "int8[]":
+    case "int16[]":
+    case "int24[]":
+    case "int32[]":
+    case "int40[]":
+    case "int48[]":
+    case "int56[]":
+    case "int64[]":
+    case "int72[]":
+    case "int80[]":
+    case "int88[]":
+    case "int96[]":
+    case "int104[]":
+    case "int112[]":
+    case "int120[]":
+    case "int128[]":
+    case "int136[]":
+    case "int144[]":
+    case "int152[]":
+    case "int160[]":
+    case "int168[]":
+    case "int176[]":
+    case "int184[]":
+    case "int192[]":
+    case "int200[]":
+    case "int208[]":
+    case "int216[]":
+    case "int224[]":
+    case "int232[]":
+    case "int240[]":
+    case "int248[]":
+    case "int256[]":
+    case "bytes1[]":
+    case "bytes2[]":
+    case "bytes3[]":
+    case "bytes4[]":
+    case "bytes5[]":
+    case "bytes6[]":
+    case "bytes7[]":
+    case "bytes8[]":
+    case "bytes9[]":
+    case "bytes10[]":
+    case "bytes11[]":
+    case "bytes12[]":
+    case "bytes13[]":
+    case "bytes14[]":
+    case "bytes15[]":
+    case "bytes16[]":
+    case "bytes17[]":
+    case "bytes18[]":
+    case "bytes19[]":
+    case "bytes20[]":
+    case "bytes21[]":
+    case "bytes22[]":
+    case "bytes23[]":
+    case "bytes24[]":
+    case "bytes25[]":
+    case "bytes26[]":
+    case "bytes27[]":
+    case "bytes28[]":
+    case "bytes29[]":
+    case "bytes30[]":
+    case "bytes31[]":
+    case "bytes32[]":
+    case "bool[]":
+    case "address[]": {
+      const staticAbiType = arrayAbiTypeToStaticAbiType(abiType);
+      const itemByteLength = staticAbiTypeToByteLength[staticAbiType];
+      if (dataSize % itemByteLength !== 0) {
+        throw new InvalidHexLengthForArrayFieldError(staticAbiType, data);
+      }
+      const items = new Array(dataSize / itemByteLength).fill(undefined).map((_, i) => {
+        const itemData = sliceHex(data, i * itemByteLength, (i + 1) * itemByteLength);
+        return decodeStaticField(staticAbiType, itemData);
+      });
+      return items as TPrimitiveType;
+    }
+  }
+
+  return assertExhaustive(abiType, `Unsupported dynamic ABI type: ${abiType}`);
+}

package/src/decodeKeyTuple.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+import { decodeKeyTuple } from "./decodeKeyTuple";
+import { abiTypesToSchema } from "./abiTypesToSchema";
+
+describe("decodeKeyTuple", () => {
+  it("can decode bool key tuple", () => {
+    expect(
+      decodeKeyTuple(abiTypesToSchema(["bool"]), ["0x0000000000000000000000000000000000000000000000000000000000000000"])
+    ).toStrictEqual([false]);
+    expect(
+      decodeKeyTuple(abiTypesToSchema(["bool"]), ["0x0000000000000000000000000000000000000000000000000000000000000001"])
+    ).toStrictEqual([true]);
+  });
+
+  it("can decode complex key tuple", () => {
+    expect(
+      decodeKeyTuple(abiTypesToSchema(["uint256", "int32", "bytes16", "address", "bool", "int8"]), [
+        "0x000000000000000000000000000000000000000000000000000000000000002a",
+        "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd6",
+        "0x1234000000000000000000000000000000000000000000000000000000000000",
+        "0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff",
+        "0x0000000000000000000000000000000000000000000000000000000000000001",
+        "0x0000000000000000000000000000000000000000000000000000000000000003",
+      ])
+    ).toStrictEqual([
+      42n,
+      -42,
+      "0x12340000000000000000000000000000",
+      "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF",
+      true,
+      3,
+    ]);
+  });
+});

package/src/decodeKeyTuple.ts

@@ -0,0 +1,11 @@
+import { Schema } from "./common";
+import { Hex, decodeAbiParameters } from "viem";
+import { StaticPrimitiveType } from "./staticAbiTypes";
+
+// key tuples are encoded in the same way as abi.encode, so we can decode them with viem
+
+export function decodeKeyTuple(keySchema: Schema, keyTuple: Hex[]): StaticPrimitiveType[] {
+  return keyTuple.map(
+    (key, index) => decodeAbiParameters([{ type: keySchema.staticFields[index] }], key)[0] as StaticPrimitiveType
+  );
+}

package/src/decodeStaticField.test-d.ts

@@ -0,0 +1,40 @@
+import { assertType, describe, it } from "vitest";
+import { decodeStaticField } from "./decodeStaticField";
+import { Hex } from "viem";
+
+describe("decodeStaticField", () => {
+  it("returns a boolean for bool ABI type", () => {
+    assertType<boolean>(decodeStaticField("bool", "0x"));
+  });
+
+  it("returns a number or bigint for uint ABI types", () => {
+    assertType<number>(decodeStaticField("uint8", "0x"));
+    assertType<number>(decodeStaticField("uint16", "0x"));
+    assertType<number>(decodeStaticField("uint32", "0x"));
+    assertType<number>(decodeStaticField("uint48", "0x"));
+    assertType<bigint>(decodeStaticField("uint56", "0x"));
+    assertType<bigint>(decodeStaticField("uint128", "0x"));
+    assertType<bigint>(decodeStaticField("uint256", "0x"));
+  });
+
+  it("returns a number or bigint for int ABI types", () => {
+    assertType<number>(decodeStaticField("int8", "0x"));
+    assertType<number>(decodeStaticField("int16", "0x"));
+    assertType<number>(decodeStaticField("int32", "0x"));
+    assertType<number>(decodeStaticField("int48", "0x"));
+    assertType<bigint>(decodeStaticField("int56", "0x"));
+    assertType<bigint>(decodeStaticField("int128", "0x"));
+    assertType<bigint>(decodeStaticField("int256", "0x"));
+  });
+
+  it("returns a hex for bytes ABI types", () => {
+    assertType<Hex>(decodeStaticField("bytes1", "0x"));
+    assertType<Hex>(decodeStaticField("bytes2", "0x"));
+    assertType<Hex>(decodeStaticField("bytes8", "0x"));
+    assertType<Hex>(decodeStaticField("bytes32", "0x"));
+  });
+
+  it("returns a hex for address ABI type", () => {
+    assertType<Hex>(decodeStaticField("address", "0x"));
+  });
+});

package/src/decodeStaticField.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, it } from "vitest";
+import { decodeStaticField } from "./decodeStaticField";
+
+describe("decodeStaticField", () => {
+  it("can decode bool", () => {
+    expect(decodeStaticField("bool", "0x00")).toBe(false);
+    expect(decodeStaticField("bool", "0x01")).toBe(true);
+
+    expect(() => decodeStaticField("bool", "0x0")).toThrow(
+      'Hex value "0x0" has length of 1, but expected length of 2 for bool type.'
+    );
+    expect(() => decodeStaticField("bool", "0x1")).toThrow(
+      'Hex value "0x1" has length of 1, but expected length of 2 for bool type.'
+    );
+    expect(() => decodeStaticField("bool", "0x000")).toThrow(
+      'Hex value "0x000" is an odd length (3). It must be an even length.'
+    );
+    expect(() => decodeStaticField("bool", "0x001")).toThrow(
+      'Hex value "0x001" is an odd length (3). It must be an even length.'
+    );
+    expect(() => decodeStaticField("bool", "0x0000")).toThrow(
+      'Hex value "0x0000" has length of 4, but expected length of 2 for bool type.'
+    );
+    expect(() => decodeStaticField("bool", "0x0001")).toThrow(
+      'Hex value "0x0001" has length of 4, but expected length of 2 for bool type.'
+    );
+  });
+
+  it("can decode uint8", () => {
+    expect(decodeStaticField("uint8", "0x00")).toBe(0);
+    expect(decodeStaticField("uint8", "0x01")).toBe(1);
+    expect(decodeStaticField("uint8", "0xff")).toBe(255);
+  });
+
+  it("can decode uint256", () => {
+    expect(decodeStaticField("uint256", "0x0000000000000000000000000000000000000000000000000000000000000000")).toBe(0n);
+    expect(decodeStaticField("uint256", "0x0000000000000000000000000000000000000000000000000000000000000001")).toBe(1n);
+    expect(decodeStaticField("uint256", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")).toBe(
+      115792089237316195423570985008687907853269984665640564039457584007913129639935n
+    );
+    expect(decodeStaticField("uint256", "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe")).toBe(
+      115792089237316195423570985008687907853269984665640564039457584007913129639934n
+    );
+  });
+
+  it("can decode int8", () => {
+    expect(decodeStaticField("int8", "0x00")).toBe(0);
+    expect(decodeStaticField("int8", "0x01")).toBe(1);
+    expect(decodeStaticField("int8", "0x7f")).toBe(127);
+    expect(decodeStaticField("int8", "0x80")).toBe(-128);
+    expect(decodeStaticField("int8", "0x81")).toBe(-127);
+    expect(decodeStaticField("int8", "0xff")).toBe(-1);
+  });
+
+  it("can decode int256", () => {
+    expect(decodeStaticField("int256", "0x0000000000000000000000000000000000000000000000000000000000000000")).toBe(0n);
+    expect(decodeStaticField("int256", "0x0000000000000000000000000000000000000000000000000000000000000001")).toBe(1n);
+    expect(decodeStaticField("int256", "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")).toBe(
+      57896044618658097711785492504343953926634992332820282019728792003956564819967n
+    );
+    expect(decodeStaticField("int256", "0x8000000000000000000000000000000000000000000000000000000000000000")).toBe(
+      -57896044618658097711785492504343953926634992332820282019728792003956564819968n
+    );
+    expect(decodeStaticField("int256", "0x8000000000000000000000000000000000000000000000000000000000000001")).toBe(
+      -57896044618658097711785492504343953926634992332820282019728792003956564819967n
+    );
+    expect(decodeStaticField("int256", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")).toBe(-1n);
+  });
+
+  it("can decode bytes", () => {
+    expect(decodeStaticField("bytes1", "0x01")).toBe("0x01");
+    expect(decodeStaticField("bytes2", "0x0001")).toBe("0x0001");
+    expect(decodeStaticField("bytes8", "0xff00ff00ff00ff00")).toBe("0xff00ff00ff00ff00");
+    expect(decodeStaticField("bytes32", "0x0000000000000000000000000000000000000000000000000000000000000001")).toBe(
+      "0x0000000000000000000000000000000000000000000000000000000000000001"
+    );
+  });
+
+  it("can decode address", () => {
+    expect(decodeStaticField("address", "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266")).toBe(
+      "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"
+    );
+    expect(decodeStaticField("address", "0xffffffffffffffffffffffffffffffffffffffff")).toBe(
+      "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF"
+    );
+
+    expect(() => decodeStaticField("address", "0x00")).toThrow(
+      'Hex value "0x00" has length of 2, but expected length of 40 for address type.'
+    );
+    expect(() => decodeStaticField("address", "0xffffffffffffffffffffffffffffffffffffffffff")).toThrow(
+      'Hex value "0xffffffffffffffffffffffffffffffffffffffffff" has length of 42, but expected length of 40 for address type.'
+    );
+  });
+});

package/src/decodeStaticField.ts

@@ -0,0 +1,145 @@
+import { Hex, getAddress, hexToBigInt, hexToBool } from "viem";
+import {
+  StaticAbiType,
+  StaticAbiTypeToPrimitiveType,
+  staticAbiTypeToByteLength,
+  staticAbiTypeToDefaultValue,
+} from "./staticAbiTypes";
+import { assertExhaustive } from "./assertExhaustive";
+import { InvalidHexLengthError, InvalidHexLengthForStaticFieldError } from "./errors";
+
+export function decodeStaticField<
+  TAbiType extends StaticAbiType,
+  TPrimitiveType extends StaticAbiTypeToPrimitiveType<TAbiType>
+>(abiType: TAbiType, data: Hex): TPrimitiveType {
+  if (data.length > 3 && data.length % 2 !== 0) {
+    throw new InvalidHexLengthError(data);
+  }
+
+  const dataSize = (data.length - 2) / 2;
+  if (dataSize !== staticAbiTypeToByteLength[abiType]) {
+    throw new InvalidHexLengthForStaticFieldError(abiType, data);
+  }
+
+  switch (abiType) {
+    case "uint8":
+    case "uint16":
+    case "uint24":
+    case "uint32":
+    case "uint40":
+    case "uint48":
+    case "uint56":
+    case "uint64":
+    case "uint72":
+    case "uint80":
+    case "uint88":
+    case "uint96":
+    case "uint104":
+    case "uint112":
+    case "uint120":
+    case "uint128":
+    case "uint136":
+    case "uint144":
+    case "uint152":
+    case "uint160":
+    case "uint168":
+    case "uint176":
+    case "uint184":
+    case "uint192":
+    case "uint200":
+    case "uint208":
+    case "uint216":
+    case "uint224":
+    case "uint232":
+    case "uint240":
+    case "uint248":
+    case "uint256":
+    case "int8":
+    case "int16":
+    case "int24":
+    case "int32":
+    case "int40":
+    case "int48":
+    case "int56":
+    case "int64":
+    case "int72":
+    case "int80":
+    case "int88":
+    case "int96":
+    case "int104":
+    case "int112":
+    case "int120":
+    case "int128":
+    case "int136":
+    case "int144":
+    case "int152":
+    case "int160":
+    case "int168":
+    case "int176":
+    case "int184":
+    case "int192":
+    case "int200":
+    case "int208":
+    case "int216":
+    case "int224":
+    case "int232":
+    case "int240":
+    case "int248":
+    case "int256": {
+      const value = hexToBigInt(data, { signed: abiType.startsWith("int") });
+      const defaultValueType = typeof staticAbiTypeToDefaultValue[abiType];
+      if (defaultValueType === "number") {
+        return Number(value) as TPrimitiveType;
+      }
+      if (defaultValueType === "bigint") {
+        return value as TPrimitiveType;
+      }
+      throw new Error(`Unexpected default value type (${defaultValueType}) for ABI type (${abiType})`);
+    }
+
+    case "bytes1":
+    case "bytes2":
+    case "bytes3":
+    case "bytes4":
+    case "bytes5":
+    case "bytes6":
+    case "bytes7":
+    case "bytes8":
+    case "bytes9":
+    case "bytes10":
+    case "bytes11":
+    case "bytes12":
+    case "bytes13":
+    case "bytes14":
+    case "bytes15":
+    case "bytes16":
+    case "bytes17":
+    case "bytes18":
+    case "bytes19":
+    case "bytes20":
+    case "bytes21":
+    case "bytes22":
+    case "bytes23":
+    case "bytes24":
+    case "bytes25":
+    case "bytes26":
+    case "bytes27":
+    case "bytes28":
+    case "bytes29":
+    case "bytes30":
+    case "bytes31":
+    case "bytes32": {
+      return data as TPrimitiveType;
+    }
+
+    case "bool": {
+      return hexToBool(data) as TPrimitiveType;
+    }
+
+    case "address": {
+      return getAddress(data) as TPrimitiveType;
+    }
+  }
+
+  return assertExhaustive(abiType, `Unsupported static ABI type: ${abiType}`);
+}

package/src/dynamicAbiTypes.test-d.ts

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

package/src/dynamicAbiTypes.ts

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