@seljs/types 1.0.0 → 1.0.1

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [1.0.1](https://github.com/abinnovision/seljs/compare/types-v1.0.0...types-v1.0.1) (2026-03-16)
+
+
+### Bug Fixes
+
+* export esm and cjs ([#23](https://github.com/abinnovision/seljs/issues/23)) ([23d525d](https://github.com/abinnovision/seljs/commit/23d525d9084d18a370d4c6307b983a857a865f59))
+
 ## 1.0.0 (2026-03-13)
 
 

package/dist/abstracts/{type-wrapper.d.ts → type-wrapper.d.cts}

@@ -1,3 +1,4 @@
+//#region src/abstracts/type-wrapper.d.ts
 /**
  * Shared interface for Solidity wrapper types (UInt256, Int256, Address).
  *
@@ -6,8 +7,9 @@
  * can identify runtime values as custom Solidity types rather than native JS
  * primitives (BigInt → "int", string → "string").
  */
-export interface TypeWrapper<T> {
-    readonly value: T;
-    valueOf: () => T;
+interface TypeWrapper<T> {
+  readonly value: T;
+  valueOf: () => T;
 }
-//# sourceMappingURL=type-wrapper.d.ts.map
+//#endregion
+export { TypeWrapper };

package/dist/abstracts/type-wrapper.d.mts

@@ -0,0 +1,15 @@
+//#region src/abstracts/type-wrapper.d.ts
+/**
+ * Shared interface for Solidity wrapper types (UInt256, Int256, Address).
+ *
+ * These wrappers are registered on the CEL environment via `registerType` so
+ * that cel-js's constructor-based type matching (`objectTypesByConstructor`)
+ * can identify runtime values as custom Solidity types rather than native JS
+ * primitives (BigInt → "int", string → "string").
+ */
+interface TypeWrapper<T> {
+  readonly value: T;
+  valueOf: () => T;
+}
+//#endregion
+export { TypeWrapper };

package/dist/{context.d.ts → context.d.cts}

@@ -1,3 +1,4 @@
+//#region src/context.d.ts
 /**
  * Infers the TypeScript type for a CEL type string.
  * Handles primitives and list<T>.
@@ -7,38 +8,38 @@ type InferCelType<T extends ContextCelType> = T extends `list<${infer E extends
  * Resolves a ContextFieldDefinition to its ContextCelType.
  */
 type ResolveCelType<T extends ContextFieldDefinition> = T extends ContextCelType ? T : T extends {
-    type: infer U extends ContextCelType;
+  type: infer U extends ContextCelType;
 } ? U : never;
 /**
  * Primitive CEL types valid for user-defined context variables.
  */
-export type PrimitiveCelType = "sol_int" | "sol_address" | "bool" | "string" | "bytes";
+type PrimitiveCelType = "sol_int" | "sol_address" | "bool" | "string" | "bytes";
 /**
  * All CEL types valid for user-defined context variables.
  * Includes primitives and list<primitive>.
  */
-export type ContextCelType = PrimitiveCelType | `list<${PrimitiveCelType}>`;
+type ContextCelType = PrimitiveCelType | `list<${PrimitiveCelType}>`;
 /**
  * Maps primitive CEL type names to their TypeScript representation.
  */
-export interface CelTypeToTs {
-    sol_int: bigint;
-    sol_address: `0x${string}`;
-    bool: boolean;
-    string: string;
-    bytes: string;
+interface CelTypeToTs {
+  sol_int: bigint;
+  sol_address: `0x${string}`;
+  bool: boolean;
+  string: string;
+  bytes: string;
 }
 /**
  * A context field can be a bare CEL type string or an object with type and description.
  */
-export type ContextFieldDefinition = ContextCelType | {
-    type: ContextCelType;
-    description: string;
+type ContextFieldDefinition = ContextCelType | {
+  type: ContextCelType;
+  description: string;
 };
 /**
  * Flat definition of context variables: key is the variable name, value is the CEL type or a typed object with description.
  */
-export type ContextDefinition = Record<string, ContextFieldDefinition>;
+type ContextDefinition = Record<string, ContextFieldDefinition>;
 /**
  * Infers the TypeScript type of context values from a ContextDefinition.
  *
@@ -51,8 +52,6 @@ export type ContextDefinition = Record<string, ContextFieldDefinition>;
  * // { addrs: `0x${string}`[] }
  * ```
  */
-export type InferContext<T extends ContextDefinition> = {
-    [K in keyof T]: InferCelType<ResolveCelType<T[K]>>;
-};
-export {};
-//# sourceMappingURL=context.d.ts.map
+type InferContext<T extends ContextDefinition> = { [K in keyof T]: InferCelType<ResolveCelType<T[K]>> };
+//#endregion
+export { CelTypeToTs, ContextCelType, ContextDefinition, ContextFieldDefinition, InferContext, PrimitiveCelType };

package/dist/context.d.mts

@@ -0,0 +1,57 @@
+//#region src/context.d.ts
+/**
+ * Infers the TypeScript type for a CEL type string.
+ * Handles primitives and list<T>.
+ */
+type InferCelType<T extends ContextCelType> = T extends `list<${infer E extends PrimitiveCelType}>` ? CelTypeToTs[E][] : T extends keyof CelTypeToTs ? CelTypeToTs[T] : never;
+/**
+ * Resolves a ContextFieldDefinition to its ContextCelType.
+ */
+type ResolveCelType<T extends ContextFieldDefinition> = T extends ContextCelType ? T : T extends {
+  type: infer U extends ContextCelType;
+} ? U : never;
+/**
+ * Primitive CEL types valid for user-defined context variables.
+ */
+type PrimitiveCelType = "sol_int" | "sol_address" | "bool" | "string" | "bytes";
+/**
+ * All CEL types valid for user-defined context variables.
+ * Includes primitives and list<primitive>.
+ */
+type ContextCelType = PrimitiveCelType | `list<${PrimitiveCelType}>`;
+/**
+ * Maps primitive CEL type names to their TypeScript representation.
+ */
+interface CelTypeToTs {
+  sol_int: bigint;
+  sol_address: `0x${string}`;
+  bool: boolean;
+  string: string;
+  bytes: string;
+}
+/**
+ * A context field can be a bare CEL type string or an object with type and description.
+ */
+type ContextFieldDefinition = ContextCelType | {
+  type: ContextCelType;
+  description: string;
+};
+/**
+ * Flat definition of context variables: key is the variable name, value is the CEL type or a typed object with description.
+ */
+type ContextDefinition = Record<string, ContextFieldDefinition>;
+/**
+ * Infers the TypeScript type of context values from a ContextDefinition.
+ *
+ * @example
+ * ```ts
+ * type Ctx = InferContext<{ user: "sol_address"; amount: "sol_int" }>;
+ * // { user: `0x${string}`; amount: bigint }
+ *
+ * type CtxList = InferContext<{ addrs: "list<sol_address>" }>;
+ * // { addrs: `0x${string}`[] }
+ * ```
+ */
+type InferContext<T extends ContextDefinition> = { [K in keyof T]: InferCelType<ResolveCelType<T[K]>> };
+//#endregion
+export { CelTypeToTs, ContextCelType, ContextDefinition, ContextFieldDefinition, InferContext, PrimitiveCelType };

package/dist/conversion.cjs

@@ -0,0 +1,41 @@
+const require_registry = require("./registry.cjs");
+//#region src/conversion.ts
+const LIST_REGEX = /^(.*)(\[\d*\])$/;
+/**
+* Checks if a Solidity type string represents a list type (e.g. "uint256[]", "address[5]") and extracts the base type.
+*
+* @param input Solidity type string to check (e.g. "uint256[]", "address[5]", "bool")
+* @return The base type string if the input is a list type (e.g. "uint256" for "uint256[]"), or null if the input is not a list type
+*/
+const tryListMatch = (input) => {
+	const match = input.match(LIST_REGEX);
+	if (match) return match[1] ?? null;
+	return null;
+};
+/**
+* Maps a raw Solidity type string to its corresponding CEL type.
+*
+* @param input The raw Solidity type string (e.g. "uint256", "address", "bool")
+* @return The corresponding CEL type name, or null if the type is not recognized
+*/
+const mapSolidityTypeToCEL = (input) => {
+	const listBaseType = tryListMatch(input);
+	if (listBaseType) {
+		const celBaseType = mapSolidityTypeToCEL(listBaseType);
+		if (celBaseType) return `list<${celBaseType}>`;
+	} else {
+		const aliasedType = require_registry.SOLIDITY_TYPES.find((type) => type.solidityAliases.includes(input));
+		if (aliasedType) return aliasedType.name;
+	}
+	return null;
+};
+/**
+* Checks if a given Solidity type string represents a list type (e.g. "uint256[]", "address[5]").
+* @param input
+*/
+const isSolidityTypeList = (input) => {
+	return tryListMatch(input) !== null;
+};
+//#endregion
+exports.isSolidityTypeList = isSolidityTypeList;
+exports.mapSolidityTypeToCEL = mapSolidityTypeToCEL;

package/dist/{conversion.d.ts → conversion.d.cts}

@@ -1,13 +1,15 @@
+//#region src/conversion.d.ts
 /**
  * Maps a raw Solidity type string to its corresponding CEL type.
  *
  * @param input The raw Solidity type string (e.g. "uint256", "address", "bool")
  * @return The corresponding CEL type name, or null if the type is not recognized
  */
-export declare const mapSolidityTypeToCEL: (input: string) => string | null;
+declare const mapSolidityTypeToCEL: (input: string) => string | null;
 /**
  * Checks if a given Solidity type string represents a list type (e.g. "uint256[]", "address[5]").
  * @param input
  */
-export declare const isSolidityTypeList: (input: string) => boolean;
-//# sourceMappingURL=conversion.d.ts.map
+declare const isSolidityTypeList: (input: string) => boolean;
+//#endregion
+export { isSolidityTypeList, mapSolidityTypeToCEL };

package/dist/conversion.d.mts

@@ -0,0 +1,15 @@
+//#region src/conversion.d.ts
+/**
+ * Maps a raw Solidity type string to its corresponding CEL type.
+ *
+ * @param input The raw Solidity type string (e.g. "uint256", "address", "bool")
+ * @return The corresponding CEL type name, or null if the type is not recognized
+ */
+declare const mapSolidityTypeToCEL: (input: string) => string | null;
+/**
+ * Checks if a given Solidity type string represents a list type (e.g. "uint256[]", "address[5]").
+ * @param input
+ */
+declare const isSolidityTypeList: (input: string) => boolean;
+//#endregion
+export { isSolidityTypeList, mapSolidityTypeToCEL };

package/dist/conversion.mjs

@@ -0,0 +1,40 @@
+import { SOLIDITY_TYPES } from "./registry.mjs";
+//#region src/conversion.ts
+const LIST_REGEX = /^(.*)(\[\d*\])$/;
+/**
+* Checks if a Solidity type string represents a list type (e.g. "uint256[]", "address[5]") and extracts the base type.
+*
+* @param input Solidity type string to check (e.g. "uint256[]", "address[5]", "bool")
+* @return The base type string if the input is a list type (e.g. "uint256" for "uint256[]"), or null if the input is not a list type
+*/
+const tryListMatch = (input) => {
+	const match = input.match(LIST_REGEX);
+	if (match) return match[1] ?? null;
+	return null;
+};
+/**
+* Maps a raw Solidity type string to its corresponding CEL type.
+*
+* @param input The raw Solidity type string (e.g. "uint256", "address", "bool")
+* @return The corresponding CEL type name, or null if the type is not recognized
+*/
+const mapSolidityTypeToCEL = (input) => {
+	const listBaseType = tryListMatch(input);
+	if (listBaseType) {
+		const celBaseType = mapSolidityTypeToCEL(listBaseType);
+		if (celBaseType) return `list<${celBaseType}>`;
+	} else {
+		const aliasedType = SOLIDITY_TYPES.find((type) => type.solidityAliases.includes(input));
+		if (aliasedType) return aliasedType.name;
+	}
+	return null;
+};
+/**
+* Checks if a given Solidity type string represents a list type (e.g. "uint256[]", "address[5]").
+* @param input
+*/
+const isSolidityTypeList = (input) => {
+	return tryListMatch(input) !== null;
+};
+//#endregion
+export { isSolidityTypeList, mapSolidityTypeToCEL };

package/dist/custom-types/solidity-address-type-wrapper.cjs

@@ -0,0 +1,38 @@
+//#region src/custom-types/solidity-address-type-wrapper.ts
+const ADDRESS_REGEX = /^0x[0-9a-fA-F]{40}$/;
+/**
+* Convert a value to a valid Ethereum address string.
+*
+* @param value
+*/
+const toAddress = (value) => {
+	if (value instanceof SolidityAddressTypeWrapper) return value.value;
+	if (typeof value !== "string") throw new TypeError(`Invalid address value: ${String(value)}`);
+	if (!SolidityAddressTypeWrapper.isValid(value)) throw new TypeError(`Invalid address value: ${value}`);
+	return value.toLowerCase();
+};
+/**
+* Ethereum address wrapper with regex-based validation.
+* Normalizes to lowercase (no viem dependency).
+*/
+var SolidityAddressTypeWrapper = class {
+	value;
+	constructor(value) {
+		this.value = toAddress(value);
+	}
+	/**
+	* Check whether a string is a valid 20-byte hex address.
+	*/
+	static isValid(value) {
+		return ADDRESS_REGEX.test(value);
+	}
+	toString() {
+		return this.value;
+	}
+	valueOf() {
+		return this.value;
+	}
+};
+//#endregion
+exports.SolidityAddressTypeWrapper = SolidityAddressTypeWrapper;
+exports.toAddress = toAddress;

package/dist/custom-types/solidity-address-type-wrapper.d.cts

@@ -0,0 +1,25 @@
+import { TypeWrapper } from "../abstracts/type-wrapper.cjs";
+
+//#region src/custom-types/solidity-address-type-wrapper.d.ts
+/**
+ * Convert a value to a valid Ethereum address string.
+ *
+ * @param value
+ */
+declare const toAddress: (value: unknown) => string;
+/**
+ * Ethereum address wrapper with regex-based validation.
+ * Normalizes to lowercase (no viem dependency).
+ */
+declare class SolidityAddressTypeWrapper implements TypeWrapper<string> {
+  readonly value: string;
+  constructor(value: unknown);
+  /**
+   * Check whether a string is a valid 20-byte hex address.
+   */
+  static isValid(value: string): boolean;
+  toString(): string;
+  valueOf(): string;
+}
+//#endregion
+export { SolidityAddressTypeWrapper, toAddress };

package/dist/custom-types/solidity-address-type-wrapper.d.mts

@@ -0,0 +1,25 @@
+import { TypeWrapper } from "../abstracts/type-wrapper.mjs";
+
+//#region src/custom-types/solidity-address-type-wrapper.d.ts
+/**
+ * Convert a value to a valid Ethereum address string.
+ *
+ * @param value
+ */
+declare const toAddress: (value: unknown) => string;
+/**
+ * Ethereum address wrapper with regex-based validation.
+ * Normalizes to lowercase (no viem dependency).
+ */
+declare class SolidityAddressTypeWrapper implements TypeWrapper<string> {
+  readonly value: string;
+  constructor(value: unknown);
+  /**
+   * Check whether a string is a valid 20-byte hex address.
+   */
+  static isValid(value: string): boolean;
+  toString(): string;
+  valueOf(): string;
+}
+//#endregion
+export { SolidityAddressTypeWrapper, toAddress };

package/dist/custom-types/solidity-address-type-wrapper.mjs

@@ -0,0 +1,37 @@
+//#region src/custom-types/solidity-address-type-wrapper.ts
+const ADDRESS_REGEX = /^0x[0-9a-fA-F]{40}$/;
+/**
+* Convert a value to a valid Ethereum address string.
+*
+* @param value
+*/
+const toAddress = (value) => {
+	if (value instanceof SolidityAddressTypeWrapper) return value.value;
+	if (typeof value !== "string") throw new TypeError(`Invalid address value: ${String(value)}`);
+	if (!SolidityAddressTypeWrapper.isValid(value)) throw new TypeError(`Invalid address value: ${value}`);
+	return value.toLowerCase();
+};
+/**
+* Ethereum address wrapper with regex-based validation.
+* Normalizes to lowercase (no viem dependency).
+*/
+var SolidityAddressTypeWrapper = class {
+	value;
+	constructor(value) {
+		this.value = toAddress(value);
+	}
+	/**
+	* Check whether a string is a valid 20-byte hex address.
+	*/
+	static isValid(value) {
+		return ADDRESS_REGEX.test(value);
+	}
+	toString() {
+		return this.value;
+	}
+	valueOf() {
+		return this.value;
+	}
+};
+//#endregion
+export { SolidityAddressTypeWrapper, toAddress };

package/dist/custom-types/solidity-int-type-wrapper.cjs

@@ -0,0 +1,31 @@
+//#region src/custom-types/solidity-int-type-wrapper.ts
+/**
+* Convert any BigInt-compatible value to a native bigint.
+* Handles SolidityIntTypeWrapper instances, bigint literals, integer numbers, and numeric strings.
+*/
+function toBigInt(value) {
+	if (value instanceof SolidityIntTypeWrapper) return value.value;
+	if (typeof value === "bigint") return value;
+	if (typeof value === "number" && Number.isInteger(value)) return BigInt(value);
+	if (typeof value === "string") return BigInt(value);
+	throw new TypeError(`Invalid integer value: ${String(value)}`);
+}
+/**
+* Unified Solidity integer wrapper for the CEL runtime.
+*
+* Wraps all Solidity integer types (uint8–uint256, int8–int256) as a single
+* CEL custom type backed by native BigInt. This bypasses cel-js's built-in
+* "int" type which enforces 64-bit overflow checks.
+*/
+var SolidityIntTypeWrapper = class {
+	value;
+	constructor(value) {
+		this.value = toBigInt(value);
+	}
+	valueOf() {
+		return this.value;
+	}
+};
+//#endregion
+exports.SolidityIntTypeWrapper = SolidityIntTypeWrapper;
+exports.toBigInt = toBigInt;

package/dist/custom-types/{solidity-int-type-wrapper.d.ts → solidity-int-type-wrapper.d.cts}

@@ -1,9 +1,11 @@
-import type { TypeWrapper } from "../abstracts/index.js";
+import { TypeWrapper } from "../abstracts/type-wrapper.cjs";
+
+//#region src/custom-types/solidity-int-type-wrapper.d.ts
 /**
  * Convert any BigInt-compatible value to a native bigint.
  * Handles SolidityIntTypeWrapper instances, bigint literals, integer numbers, and numeric strings.
  */
-export declare function toBigInt(value: unknown): bigint;
+declare function toBigInt(value: unknown): bigint;
 /**
  * Unified Solidity integer wrapper for the CEL runtime.
  *
@@ -11,9 +13,10 @@ export declare function toBigInt(value: unknown): bigint;
  * CEL custom type backed by native BigInt. This bypasses cel-js's built-in
  * "int" type which enforces 64-bit overflow checks.
  */
-export declare class SolidityIntTypeWrapper implements TypeWrapper<bigint> {
-    readonly value: bigint;
-    constructor(value: unknown);
-    valueOf(): bigint;
+declare class SolidityIntTypeWrapper implements TypeWrapper<bigint> {
+  readonly value: bigint;
+  constructor(value: unknown);
+  valueOf(): bigint;
 }
-//# sourceMappingURL=solidity-int-type-wrapper.d.ts.map
+//#endregion
+export { SolidityIntTypeWrapper, toBigInt };

package/dist/custom-types/solidity-int-type-wrapper.d.mts

@@ -0,0 +1,22 @@
+import { TypeWrapper } from "../abstracts/type-wrapper.mjs";
+
+//#region src/custom-types/solidity-int-type-wrapper.d.ts
+/**
+ * Convert any BigInt-compatible value to a native bigint.
+ * Handles SolidityIntTypeWrapper instances, bigint literals, integer numbers, and numeric strings.
+ */
+declare function toBigInt(value: unknown): bigint;
+/**
+ * Unified Solidity integer wrapper for the CEL runtime.
+ *
+ * Wraps all Solidity integer types (uint8–uint256, int8–int256) as a single
+ * CEL custom type backed by native BigInt. This bypasses cel-js's built-in
+ * "int" type which enforces 64-bit overflow checks.
+ */
+declare class SolidityIntTypeWrapper implements TypeWrapper<bigint> {
+  readonly value: bigint;
+  constructor(value: unknown);
+  valueOf(): bigint;
+}
+//#endregion
+export { SolidityIntTypeWrapper, toBigInt };

package/dist/custom-types/solidity-int-type-wrapper.mjs

@@ -0,0 +1,30 @@
+//#region src/custom-types/solidity-int-type-wrapper.ts
+/**
+* Convert any BigInt-compatible value to a native bigint.
+* Handles SolidityIntTypeWrapper instances, bigint literals, integer numbers, and numeric strings.
+*/
+function toBigInt(value) {
+	if (value instanceof SolidityIntTypeWrapper) return value.value;
+	if (typeof value === "bigint") return value;
+	if (typeof value === "number" && Number.isInteger(value)) return BigInt(value);
+	if (typeof value === "string") return BigInt(value);
+	throw new TypeError(`Invalid integer value: ${String(value)}`);
+}
+/**
+* Unified Solidity integer wrapper for the CEL runtime.
+*
+* Wraps all Solidity integer types (uint8–uint256, int8–int256) as a single
+* CEL custom type backed by native BigInt. This bypasses cel-js's built-in
+* "int" type which enforces 64-bit overflow checks.
+*/
+var SolidityIntTypeWrapper = class {
+	value;
+	constructor(value) {
+		this.value = toBigInt(value);
+	}
+	valueOf() {
+		return this.value;
+	}
+};
+//#endregion
+export { SolidityIntTypeWrapper, toBigInt };

package/dist/index.cjs

@@ -0,0 +1,15 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_solidity_address_type_wrapper = require("./custom-types/solidity-address-type-wrapper.cjs");
+const require_solidity_int_type_wrapper = require("./custom-types/solidity-int-type-wrapper.cjs");
+const require_registry = require("./registry.cjs");
+const require_conversion = require("./conversion.cjs");
+const require_units = require("./units.cjs");
+exports.SOLIDITY_TYPES = require_registry.SOLIDITY_TYPES;
+exports.SolidityAddressTypeWrapper = require_solidity_address_type_wrapper.SolidityAddressTypeWrapper;
+exports.SolidityIntTypeWrapper = require_solidity_int_type_wrapper.SolidityIntTypeWrapper;
+exports.formatUnitsValue = require_units.formatUnitsValue;
+exports.isSolidityTypeList = require_conversion.isSolidityTypeList;
+exports.mapSolidityTypeToCEL = require_conversion.mapSolidityTypeToCEL;
+exports.parseUnitsValue = require_units.parseUnitsValue;
+exports.toAddress = require_solidity_address_type_wrapper.toAddress;
+exports.toBigInt = require_solidity_int_type_wrapper.toBigInt;

package/dist/index.d.cts

@@ -0,0 +1,8 @@
+import { TypeWrapper } from "./abstracts/type-wrapper.cjs";
+import { SolidityAddressTypeWrapper, toAddress } from "./custom-types/solidity-address-type-wrapper.cjs";
+import { SolidityIntTypeWrapper, toBigInt } from "./custom-types/solidity-int-type-wrapper.cjs";
+import { SOLIDITY_TYPES } from "./registry.cjs";
+import { isSolidityTypeList, mapSolidityTypeToCEL } from "./conversion.cjs";
+import { formatUnitsValue, parseUnitsValue } from "./units.cjs";
+import { CelTypeToTs, ContextCelType, ContextDefinition, ContextFieldDefinition, InferContext, PrimitiveCelType } from "./context.cjs";
+export { CelTypeToTs, ContextCelType, ContextDefinition, ContextFieldDefinition, InferContext, PrimitiveCelType, SOLIDITY_TYPES, SolidityAddressTypeWrapper, SolidityIntTypeWrapper, TypeWrapper, formatUnitsValue, isSolidityTypeList, mapSolidityTypeToCEL, parseUnitsValue, toAddress, toBigInt };

package/dist/index.d.mts

@@ -0,0 +1,8 @@
+import { TypeWrapper } from "./abstracts/type-wrapper.mjs";
+import { SolidityAddressTypeWrapper, toAddress } from "./custom-types/solidity-address-type-wrapper.mjs";
+import { SolidityIntTypeWrapper, toBigInt } from "./custom-types/solidity-int-type-wrapper.mjs";
+import { SOLIDITY_TYPES } from "./registry.mjs";
+import { isSolidityTypeList, mapSolidityTypeToCEL } from "./conversion.mjs";
+import { formatUnitsValue, parseUnitsValue } from "./units.mjs";
+import { CelTypeToTs, ContextCelType, ContextDefinition, ContextFieldDefinition, InferContext, PrimitiveCelType } from "./context.mjs";
+export { CelTypeToTs, ContextCelType, ContextDefinition, ContextFieldDefinition, InferContext, PrimitiveCelType, SOLIDITY_TYPES, SolidityAddressTypeWrapper, SolidityIntTypeWrapper, TypeWrapper, formatUnitsValue, isSolidityTypeList, mapSolidityTypeToCEL, parseUnitsValue, toAddress, toBigInt };

package/dist/index.mjs

@@ -0,0 +1,6 @@
+import { SolidityAddressTypeWrapper, toAddress } from "./custom-types/solidity-address-type-wrapper.mjs";
+import { SolidityIntTypeWrapper, toBigInt } from "./custom-types/solidity-int-type-wrapper.mjs";
+import { SOLIDITY_TYPES } from "./registry.mjs";
+import { isSolidityTypeList, mapSolidityTypeToCEL } from "./conversion.mjs";
+import { formatUnitsValue, parseUnitsValue } from "./units.mjs";
+export { SOLIDITY_TYPES, SolidityAddressTypeWrapper, SolidityIntTypeWrapper, formatUnitsValue, isSolidityTypeList, mapSolidityTypeToCEL, parseUnitsValue, toAddress, toBigInt };

package/dist/registry.cjs

@@ -0,0 +1,65 @@
+const require_solidity_address_type_wrapper = require("./custom-types/solidity-address-type-wrapper.cjs");
+const require_solidity_int_type_wrapper = require("./custom-types/solidity-int-type-wrapper.cjs");
+//#region src/registry.ts
+/**
+* Generates the list of Solidity bytes type aliases (bytes, bytes1, ..., bytes32).
+*/
+const generateBytesAliases = () => {
+	const aliases = ["bytes"];
+	for (let size = 1; size <= 32; size++) aliases.push(`bytes${String(size)}`);
+	return aliases;
+};
+/**
+* Generates the list of Solidity int/uint type aliases (int, uint, int8, uint8, ..., int256, uint256).
+*/
+const generateIntAliases = () => {
+	const aliases = ["uint", "int"];
+	for (let size = 8; size <= 256; size += 8) aliases.push(`uint${String(size)}`);
+	for (let size = 8; size <= 256; size += 8) aliases.push(`int${String(size)}`);
+	return aliases;
+};
+/**
+* The single source of truth for Solidity type identity in the CEL environment.
+* Keyed by CEL type name.
+*/
+const SOLIDITY_TYPES = [
+	{
+		type: "builtin",
+		name: "bytes",
+		solidityAliases: generateBytesAliases()
+	},
+	{
+		type: "builtin",
+		name: "string",
+		solidityAliases: ["string"]
+	},
+	{
+		type: "builtin",
+		name: "bool",
+		solidityAliases: ["bool"]
+	},
+	{
+		type: "custom",
+		name: "sol_address",
+		solidityAliases: ["address"],
+		wrapperClass: require_solidity_address_type_wrapper.SolidityAddressTypeWrapper,
+		schema: {
+			kind: "primitive",
+			description: "20-byte Ethereum address"
+		},
+		castSignatures: ["solAddress(string): sol_address"]
+	},
+	{
+		type: "custom",
+		name: "sol_int",
+		solidityAliases: generateIntAliases(),
+		wrapperClass: require_solidity_int_type_wrapper.SolidityIntTypeWrapper,
+		schema: {
+			kind: "primitive",
+			description: "Arbitrary-size integer"
+		},
+		castSignatures: ["solInt(string): sol_int", "solInt(int): sol_int"]
+	}
+];
+//#endregion
+exports.SOLIDITY_TYPES = SOLIDITY_TYPES;