@seljs/types 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+## 1.0.0 (2026-03-13)
+
+
+### Features
+
+* first implementation of seljs ([7548fe0](https://github.com/abinnovision/seljs/commit/7548fe06cbb22ec6b74b20e38ef07d026b3f8def))

package/LICENSE.md

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1.  Definitions.
+
+    "License" shall mean the terms and conditions for use, reproduction,
+    and distribution as defined by Sections 1 through 9 of this document.
+
+    "Licensor" shall mean the copyright owner or entity authorized by
+    the copyright owner that is granting the License.
+
+    "Legal Entity" shall mean the union of the acting entity and all
+    other entities that control, are controlled by, or are under common
+    control with that entity. For the purposes of this definition,
+    "control" means (i) the power, direct or indirect, to cause the
+    direction or management of such entity, whether by contract or
+    otherwise, or (ii) ownership of fifty percent (50%) or more of the
+    outstanding shares, or (iii) beneficial ownership of such entity.
+
+    "You" (or "Your") shall mean an individual or Legal Entity
+    exercising permissions granted by this License.
+
+    "Source" form shall mean the preferred form for making modifications,
+    including but not limited to software source code, documentation
+    source, and configuration files.
+
+    "Object" form shall mean any form resulting from mechanical
+    transformation or translation of a Source form, including but
+    not limited to compiled object code, generated documentation,
+    and conversions to other media types.
+
+    "Work" shall mean the work of authorship, whether in Source or
+    Object form, made available under the License, as indicated by a
+    copyright notice that is included in or attached to the work
+    (an example is provided in the Appendix below).
+
+    "Derivative Works" shall mean any work, whether in Source or Object
+    form, that is based on (or derived from) the Work and for which the
+    editorial revisions, annotations, elaborations, or other modifications
+    represent, as a whole, an original work of authorship. For the purposes
+    of this License, Derivative Works shall not include works that remain
+    separable from, or merely link (or bind by name) to the interfaces of,
+    the Work and Derivative Works thereof.
+
+    "Contribution" shall mean any work of authorship, including
+    the original version of the Work and any modifications or additions
+    to that Work or Derivative Works thereof, that is intentionally
+    submitted to Licensor for inclusion in the Work by the copyright owner
+    or by an individual or Legal Entity authorized to submit on behalf of
+    the copyright owner. For the purposes of this definition, "submitted"
+    means any form of electronic, verbal, or written communication sent
+    to the Licensor or its representatives, including but not limited to
+    communication on electronic mailing lists, source code control systems,
+    and issue tracking systems that are managed by, or on behalf of, the
+    Licensor for the purpose of discussing and improving the Work, but
+    excluding communication that is conspicuously marked or otherwise
+    designated in writing by the copyright owner as "Not a Contribution."
+
+    "Contributor" shall mean Licensor and any individual or Legal Entity
+    on behalf of whom a Contribution has been received by Licensor and
+    subsequently incorporated within the Work.
+
+2.  Grant of Copyright License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    copyright license to reproduce, prepare Derivative Works of,
+    publicly display, publicly perform, sublicense, and distribute the
+    Work and such Derivative Works in Source or Object form.
+
+3.  Grant of Patent License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    (except as stated in this section) patent license to make, have made,
+    use, offer to sell, sell, import, and otherwise transfer the Work,
+    where such license applies only to those patent claims licensable
+    by such Contributor that are necessarily infringed by their
+    Contribution(s) alone or by combination of their Contribution(s)
+    with the Work to which such Contribution(s) was submitted. If You
+    institute patent litigation against any entity (including a
+    cross-claim or counterclaim in a lawsuit) alleging that the Work
+    or a Contribution incorporated within the Work constitutes direct
+    or contributory patent infringement, then any patent licenses
+    granted to You under this License for that Work shall terminate
+    as of the date such litigation is filed.
+
+4.  Redistribution. You may reproduce and distribute copies of the
+    Work or Derivative Works thereof in any medium, with or without
+    modifications, and in Source or Object form, provided that You
+    meet the following conditions:
+
+    (a) You must give any other recipients of the Work or
+    Derivative Works a copy of this License; and
+
+    (b) You must cause any modified files to carry prominent notices
+    stating that You changed the files; and
+
+    (c) You must retain, in the Source form of any Derivative Works
+    that You distribute, all copyright, patent, trademark, and
+    attribution notices from the Source form of the Work,
+    excluding those notices that do not pertain to any part of
+    the Derivative Works; and
+
+    (d) If the Work includes a "NOTICE" text file as part of its
+    distribution, then any Derivative Works that You distribute must
+    include a readable copy of the attribution notices contained
+    within such NOTICE file, excluding those notices that do not
+    pertain to any part of the Derivative Works, in at least one
+    of the following places: within a NOTICE text file distributed
+    as part of the Derivative Works; within the Source form or
+    documentation, if provided along with the Derivative Works; or,
+    within a display generated by the Derivative Works, if and
+    wherever such third-party notices normally appear. The contents
+    of the NOTICE file are for informational purposes only and
+    do not modify the License. You may add Your own attribution
+    notices within Derivative Works that You distribute, alongside
+    or as an addendum to the NOTICE text from the Work, provided
+    that such additional attribution notices cannot be construed
+    as modifying the License.
+
+    You may add Your own copyright statement to Your modifications and
+    may provide additional or different license terms and conditions
+    for use, reproduction, or distribution of Your modifications, or
+    for any such Derivative Works as a whole, provided Your use,
+    reproduction, and distribution of the Work otherwise complies with
+    the conditions stated in this License.
+
+5.  Submission of Contributions. Unless You explicitly state otherwise,
+    any Contribution intentionally submitted for inclusion in the Work
+    by You to the Licensor shall be under the terms and conditions of
+    this License, without any additional terms or conditions.
+    Notwithstanding the above, nothing herein shall supersede or modify
+    the terms of any separate license agreement you may have executed
+    with Licensor regarding such Contributions.
+
+6.  Trademarks. This License does not grant permission to use the trade
+    names, trademarks, service marks, or product names of the Licensor,
+    except as required for reasonable and customary use in describing the
+    origin of the Work and reproducing the content of the NOTICE file.
+
+7.  Disclaimer of Warranty. Unless required by applicable law or
+    agreed to in writing, Licensor provides the Work (and each
+    Contributor provides its Contributions) on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+    implied, including, without limitation, any warranties or conditions
+    of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+    PARTICULAR PURPOSE. You are solely responsible for determining the
+    appropriateness of using or redistributing the Work and assume any
+    risks associated with Your exercise of permissions under this License.
+
+8.  Limitation of Liability. In no event and under no legal theory,
+    whether in tort (including negligence), contract, or otherwise,
+    unless required by applicable law (such as deliberate and grossly
+    negligent acts) or agreed to in writing, shall any Contributor be
+    liable to You for damages, including any direct, indirect, special,
+    incidental, or consequential damages of any character arising as a
+    result of this License or out of the use or inability to use the
+    Work (including but not limited to damages for loss of goodwill,
+    work stoppage, computer failure or malfunction, or any and all
+    other commercial damages or losses), even if such Contributor
+    has been advised of the possibility of such damages.
+
+9.  Accepting Warranty or Additional Liability. While redistributing
+    the Work or Derivative Works thereof, You may choose to offer,
+    and charge a fee for, acceptance of support, warranty, indemnity,
+    or other liability obligations and/or rights consistent with this
+    License. However, in accepting such obligations, You may act only
+    on Your own behalf and on Your sole responsibility, not on behalf
+    of any other Contributor, and only if You agree to indemnify,
+    defend, and hold each Contributor harmless for any liability
+    incurred by, or claims asserted against, such Contributor by reason
+    of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+Copyright 2026 abi group GmbH
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,5 @@
+# sel-types
+
+Type primitives and type knowledge for the SEL system. Provides value wrappers for Solidity types, a type registry with identity data for the CEL environment, and mappings from Solidity type strings to CEL type names.
+
+Zero external dependencies. Every other SEL package depends on this one.

package/dist/abstracts/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./type-wrapper.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/abstracts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/abstracts/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}

package/dist/abstracts/index.js

@@ -0,0 +1 @@
+export * from "./type-wrapper.js";

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

@@ -0,0 +1,13 @@
+/**
+ * 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").
+ */
+export interface TypeWrapper<T> {
+    readonly value: T;
+    valueOf: () => T;
+}
+//# sourceMappingURL=type-wrapper.d.ts.map

package/dist/abstracts/type-wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-wrapper.d.ts","sourceRoot":"","sources":["../../src/abstracts/type-wrapper.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC,CAAC;CACjB"}

package/dist/abstracts/type-wrapper.js

@@ -0,0 +1 @@
+export {};

package/dist/context.d.ts

@@ -0,0 +1,58 @@
+/**
+ * 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.
+ */
+export 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}>`;
+/**
+ * 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;
+}
+/**
+ * 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;
+};
+/**
+ * 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>;
+/**
+ * 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}`[] }
+ * ```
+ */
+export type InferContext<T extends ContextDefinition> = {
+    [K in keyof T]: InferCelType<ResolveCelType<T[K]>>;
+};
+export {};
+//# sourceMappingURL=context.d.ts.map

package/dist/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,KAAK,YAAY,CAAC,CAAC,SAAS,cAAc,IACzC,CAAC,SAAS,QAAQ,MAAM,CAAC,SAAS,gBAAgB,GAAG,GAClD,WAAW,CAAC,CAAC,CAAC,EAAE,GAChB,CAAC,SAAS,MAAM,WAAW,GAC1B,WAAW,CAAC,CAAC,CAAC,GACd,KAAK,CAAC;AAEX;;GAEG;AACH,KAAK,cAAc,CAAC,CAAC,SAAS,sBAAsB,IAAI,CAAC,SAAS,cAAc,GAC7E,CAAC,GACD,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC,SAAS,cAAc,CAAA;CAAE,GACjD,CAAC,GACD,KAAK,CAAC;AAEV;;GAEG;AACH,MAAM,MAAM,gBAAgB,GACzB,SAAS,GACT,aAAa,GACb,MAAM,GACN,QAAQ,GACR,OAAO,CAAC;AAEX;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,gBAAgB,GAAG,QAAQ,gBAAgB,GAAG,CAAC;AAE5E;;GAEG;AACH,MAAM,WAAW,WAAW;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,KAAK,MAAM,EAAE,CAAC;IAC3B,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAC/B,cAAc,GACd;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjD;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;AAEvE;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,iBAAiB,IAAI;KACtD,CAAC,IAAI,MAAM,CAAC,GAAG,YAAY,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAClD,CAAC"}

package/dist/context.js

@@ -0,0 +1 @@
+export {};

package/dist/context.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=context.spec.d.ts.map

package/dist/context.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.spec.d.ts","sourceRoot":"","sources":["../src/context.spec.ts"],"names":[],"mappings":""}

package/dist/context.spec.js

@@ -0,0 +1,38 @@
+import { describe, expectTypeOf, it } from "vitest";
+describe("src/context.ts", () => {
+    describe("contextCelType", () => {
+        it("accepts primitive types", () => {
+            expectTypeOf().toExtend();
+            expectTypeOf().toExtend();
+            expectTypeOf().toExtend();
+            expectTypeOf().toExtend();
+            expectTypeOf().toExtend();
+        });
+        it("accepts list<primitive> types", () => {
+            expectTypeOf().toExtend();
+            expectTypeOf().toExtend();
+            expectTypeOf().toExtend();
+            expectTypeOf().toExtend();
+            expectTypeOf().toExtend();
+        });
+        it("rejects invalid types", () => {
+            expectTypeOf().not.toExtend();
+            expectTypeOf().not.toExtend();
+            expectTypeOf().not.toExtend();
+        });
+    });
+    describe("inferContext", () => {
+        it("infers primitive types", () => {
+            expectTypeOf().toEqualTypeOf();
+        });
+        it("infers list types", () => {
+            expectTypeOf().toEqualTypeOf();
+        });
+        it("infers list<bool> type", () => {
+            expectTypeOf().toEqualTypeOf();
+        });
+        it("infers types with description objects", () => {
+            expectTypeOf().toEqualTypeOf();
+        });
+    });
+});

package/dist/conversion.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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;
+/**
+ * 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

package/dist/conversion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversion.d.ts","sourceRoot":"","sources":["../src/conversion.ts"],"names":[],"mappings":"AAqBA;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAAI,OAAO,MAAM,KAAG,MAAM,GAAG,IAuB7D,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,MAAM,KAAG,OAElD,CAAC"}

package/dist/conversion.js

@@ -0,0 +1,48 @@
+import { SOLIDITY_TYPES } from "./registry.js";
+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
+ */
+export const mapSolidityTypeToCEL = (input) => {
+    // First check if the input type represents a list type.
+    const listBaseType = tryListMatch(input);
+    if (listBaseType) {
+        // Make a recursive call into this function to resolve the base type of the list.
+        const celBaseType = mapSolidityTypeToCEL(listBaseType);
+        if (celBaseType) {
+            return `list<${celBaseType}>`;
+        }
+    }
+    else {
+        // Go through the registry and check all the aliases for each registered type to see if any of them match the input type string.
+        const aliasedType = SOLIDITY_TYPES.find((type) => type.solidityAliases.includes(input));
+        if (aliasedType) {
+            return aliasedType.name;
+        }
+    }
+    // Return null if there is no match.
+    return null;
+};
+/**
+ * Checks if a given Solidity type string represents a list type (e.g. "uint256[]", "address[5]").
+ * @param input
+ */
+export const isSolidityTypeList = (input) => {
+    return tryListMatch(input) !== null;
+};

package/dist/conversion.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=conversion.spec.d.ts.map

package/dist/conversion.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversion.spec.d.ts","sourceRoot":"","sources":["../src/conversion.spec.ts"],"names":[],"mappings":""}

package/dist/conversion.spec.js

@@ -0,0 +1,53 @@
+import { describe, expect, it } from "vitest";
+import { isSolidityTypeList, mapSolidityTypeToCEL } from "./conversion.js";
+describe("src/conversion.ts", () => {
+    describe("mapSolidityTypeToCEL", () => {
+        it.each([
+            // Integer types
+            ["uint256", "sol_int"],
+            ["uint8", "sol_int"],
+            ["uint128", "sol_int"],
+            ["uint", "sol_int"],
+            ["int256", "sol_int"],
+            ["int8", "sol_int"],
+            ["int", "sol_int"],
+            // Address
+            ["address", "sol_address"],
+            // Builtins
+            ["bool", "bool"],
+            ["string", "string"],
+            // Bytes
+            ["bytes", "bytes"],
+            ["bytes1", "bytes"],
+            ["bytes20", "bytes"],
+            ["bytes32", "bytes"],
+            // Arrays
+            ["uint256[]", "list<sol_int>"],
+            ["address[]", "list<sol_address>"],
+            ["bool[]", "list<bool>"],
+            ["uint256[5]", "list<sol_int>"],
+            ["bytes32[]", "list<bytes>"],
+            ["uint256[][]", "list<list<sol_int>>"],
+            // Unrecognized / not sel-types concern
+            ["tuple", null],
+            ["unknown", null],
+            ["", null],
+            ["uint512", null],
+            ["bytes33", null],
+        ])("maps %j → %j", (input, expected) => {
+            expect(mapSolidityTypeToCEL(input)).toBe(expected);
+        });
+    });
+    describe("isSolidityTypeList", () => {
+        it.each([
+            ["uint256[]", true],
+            ["uint256[5]", true],
+            ["uint256[][]", true],
+            ["uint256", false],
+            ["address", false],
+            ["tuple", false],
+        ])("isSolidityTypeList(%j) → %j", (input, expected) => {
+            expect(isSolidityTypeList(input)).toBe(expected);
+        });
+    });
+});

package/dist/custom-types/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./solidity-address-type-wrapper.js";
+export * from "./solidity-int-type-wrapper.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/custom-types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/custom-types/index.ts"],"names":[],"mappings":"AAAA,cAAc,oCAAoC,CAAC;AACnD,cAAc,gCAAgC,CAAC"}

package/dist/custom-types/index.js

@@ -0,0 +1,2 @@
+export * from "./solidity-address-type-wrapper.js";
+export * from "./solidity-int-type-wrapper.js";

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

@@ -0,0 +1,22 @@
+import type { TypeWrapper } from "../abstracts/index.js";
+/**
+ * Convert a value to a valid Ethereum address string.
+ *
+ * @param value
+ */
+export declare const toAddress: (value: unknown) => string;
+/**
+ * Ethereum address wrapper with regex-based validation.
+ * Normalizes to lowercase (no viem dependency).
+ */
+export 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;
+}
+//# sourceMappingURL=solidity-address-type-wrapper.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"solidity-address-type-wrapper.d.ts","sourceRoot":"","sources":["../../src/custom-types/solidity-address-type-wrapper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAIzD;;;;GAIG;AACH,eAAO,MAAM,SAAS,GAAI,OAAO,OAAO,KAAG,MAc1C,CAAC;AAEF;;;GAGG;AACH,qBAAa,0BAA2B,YAAW,WAAW,CAAC,MAAM,CAAC;IACrE,SAAgB,KAAK,EAAE,MAAM,CAAC;gBAEX,KAAK,EAAE,OAAO;IAIjC;;OAEG;WACW,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAItC,QAAQ,IAAI,MAAM;IAIlB,OAAO,IAAI,MAAM;CAGxB"}

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

@@ -0,0 +1,40 @@
+const ADDRESS_REGEX = /^0x[0-9a-fA-F]{40}$/;
+/**
+ * Convert a value to a valid Ethereum address string.
+ *
+ * @param value
+ */
+export 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).
+ */
+export class SolidityAddressTypeWrapper {
+    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;
+    }
+}

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

@@ -0,0 +1,19 @@
+import type { TypeWrapper } from "../abstracts/index.js";
+/**
+ * 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;
+/**
+ * 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.
+ */
+export declare class SolidityIntTypeWrapper implements TypeWrapper<bigint> {
+    readonly value: bigint;
+    constructor(value: unknown);
+    valueOf(): bigint;
+}
+//# sourceMappingURL=solidity-int-type-wrapper.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"solidity-int-type-wrapper.d.ts","sourceRoot":"","sources":["../../src/custom-types/solidity-int-type-wrapper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAkB/C;AAED;;;;;;GAMG;AACH,qBAAa,sBAAuB,YAAW,WAAW,CAAC,MAAM,CAAC;IACjE,SAAgB,KAAK,EAAE,MAAM,CAAC;gBAEX,KAAK,EAAE,OAAO;IAI1B,OAAO,IAAI,MAAM;CAGxB"}

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

@@ -0,0 +1,35 @@
+/**
+ * Convert any BigInt-compatible value to a native bigint.
+ * Handles SolidityIntTypeWrapper instances, bigint literals, integer numbers, and numeric strings.
+ */
+export 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.
+ */
+export class SolidityIntTypeWrapper {
+    value;
+    constructor(value) {
+        this.value = toBigInt(value);
+    }
+    valueOf() {
+        return this.value;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./abstracts/index.js";
+export * from "./custom-types/index.js";
+export * from "./registry.js";
+export * from "./conversion.js";
+export * from "./units.js";
+export * from "./context.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from "./abstracts/index.js";
+export * from "./custom-types/index.js";
+export * from "./registry.js";
+export * from "./conversion.js";
+export * from "./units.js";
+export * from "./context.js";

package/dist/registry.d.ts

@@ -0,0 +1,26 @@
+import type { TypeWrapper } from "./abstracts/index.js";
+import type { AbiType } from "abitype";
+/**
+ * Unified representation of Solidity type identity in the CEL environment.
+ */
+type SolidityTypeIdentity = {
+    name: string;
+    solidityAliases: readonly AbiType[];
+} & ({
+    type: "builtin";
+} | {
+    type: "custom";
+    schema: {
+        kind: "primitive";
+        description: string;
+    };
+    wrapperClass: new (value: unknown) => TypeWrapper<unknown>;
+    castSignatures: readonly string[];
+});
+/**
+ * The single source of truth for Solidity type identity in the CEL environment.
+ * Keyed by CEL type name.
+ */
+export declare const SOLIDITY_TYPES: SolidityTypeIdentity[];
+export {};
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,OAAO,EAA8B,MAAM,SAAS,CAAC;AAEnE;;GAEG;AACH,KAAK,oBAAoB,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,EAAE,SAAS,OAAO,EAAE,CAAC;CACpC,GAAG,CACD;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IACA,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE;QAAE,IAAI,EAAE,WAAW,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;IACnD,YAAY,EAAE,KAAK,KAAK,EAAE,OAAO,KAAK,WAAW,CAAC,OAAO,CAAC,CAAC;IAC3D,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;CACjC,CACH,CAAC;AAmCF;;;GAGG;AACH,eAAO,MAAM,cAAc,EA4BW,oBAAoB,EAAE,CAAC"}

package/dist/registry.js

@@ -0,0 +1,58 @@
+import { SolidityAddressTypeWrapper, SolidityIntTypeWrapper, } from "./custom-types/index.js";
+/**
+ * Generates the list of Solidity bytes type aliases (bytes, bytes1, ..., bytes32).
+ */
+const generateBytesAliases = () => {
+    const aliases = ["bytes"];
+    // Generate bytes1 to bytes32 aliases.
+    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"];
+    // Generate uint8 to uint256 aliases (including "uint" as alias for "uint256").
+    for (let size = 8; size <= 256; size += 8) {
+        aliases.push(`uint${String(size)}`);
+    }
+    // Generate int8 to int256 aliases (including "int" as alias for "int256").
+    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.
+ */
+export const SOLIDITY_TYPES = [
+    /*
+     * - Byte types: bytes, bytes1-bytes32 → "bytes"
+     * This maps all byte array types to a single "bytes" CEL type.
+     */
+    { type: "builtin", name: "bytes", solidityAliases: generateBytesAliases() },
+    { type: "builtin", name: "string", solidityAliases: ["string"] },
+    { type: "builtin", name: "bool", solidityAliases: ["bool"] },
+    // - Address type: address → "sol_address"
+    {
+        type: "custom",
+        name: "sol_address",
+        solidityAliases: ["address"],
+        wrapperClass: SolidityAddressTypeWrapper,
+        schema: { kind: "primitive", description: "20-byte Ethereum address" },
+        castSignatures: ["solAddress(string): sol_address"],
+    },
+    // - Integer types: sol_int
+    {
+        type: "custom",
+        name: "sol_int",
+        solidityAliases: generateIntAliases(),
+        wrapperClass: SolidityIntTypeWrapper,
+        schema: { kind: "primitive", description: "Arbitrary-size integer" },
+        castSignatures: ["solInt(string): sol_int", "solInt(int): sol_int"],
+    },
+];

package/dist/registry.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=registry.spec.d.ts.map

package/dist/registry.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.spec.d.ts","sourceRoot":"","sources":["../src/registry.spec.ts"],"names":[],"mappings":""}

package/dist/registry.spec.js

@@ -0,0 +1,57 @@
+import { describe, expect, it } from "vitest";
+import { SolidityAddressTypeWrapper, SolidityIntTypeWrapper, } from "./custom-types/index.js";
+import { SOLIDITY_TYPES } from "./registry.js";
+describe("src/registry.ts", () => {
+    const findByName = (name) => SOLIDITY_TYPES.find((t) => t.name === name);
+    describe("registered types", () => {
+        it.each(["bytes", "string", "bool", "sol_address", "sol_int"])("has %j registered", (name) => {
+            expect(findByName(name)).toBeDefined();
+        });
+    });
+    describe("builtins", () => {
+        it.each([
+            ["bytes", "builtin"],
+            ["string", "builtin"],
+            ["bool", "builtin"],
+        ])("%j is type %j", (name, expectedType) => {
+            expect(findByName(name)?.type).toBe(expectedType);
+        });
+    });
+    describe("custom types", () => {
+        it.each([
+            ["sol_address", SolidityAddressTypeWrapper],
+            ["sol_int", SolidityIntTypeWrapper],
+        ])("%j has wrapperClass", (name, expectedClass) => {
+            const entry = findByName(name);
+            expect(entry?.type).toBe("custom");
+            expect(entry.wrapperClass).toBe(expectedClass);
+        });
+    });
+    describe("bytes aliases", () => {
+        const bytesEntry = findByName("bytes");
+        it("includes dynamic bytes", () => {
+            expect(bytesEntry?.solidityAliases).toContain("bytes");
+        });
+        it.each(["bytes1", "bytes16", "bytes32"])("includes %j", (alias) => {
+            expect(bytesEntry?.solidityAliases).toContain(alias);
+        });
+        it("has 33 aliases (bytes + bytes1..bytes32)", () => {
+            expect(bytesEntry?.solidityAliases).toHaveLength(33);
+        });
+    });
+    describe("int aliases", () => {
+        const intEntry = findByName("sol_int");
+        it.each(["uint", "int", "uint8", "int8", "uint256", "int256"])("includes %j", (alias) => {
+            expect(intEntry?.solidityAliases).toContain(alias);
+        });
+        it("has 66 aliases (uint + int + uint8..uint256 + int8..int256)", () => {
+            // 2 bare aliases + 32 uint sizes + 32 int sizes = 66
+            expect(intEntry?.solidityAliases).toHaveLength(66);
+        });
+    });
+    describe("address aliases", () => {
+        it("has only 'address'", () => {
+            expect(findByName("sol_address")?.solidityAliases).toEqual(["address"]);
+        });
+    });
+});

package/dist/units.d.ts

@@ -0,0 +1,15 @@
+import { SolidityIntTypeWrapper } from "./custom-types/index.js";
+/**
+ * Parse a human-readable value into a scaled sol_int.
+ * Mirrors viem/ethers parseUnits behavior.
+ *
+ * Accepts: bigint, number (int or float), string (decimal notation), SolidityIntTypeWrapper.
+ * Floats are converted to string first to avoid floating-point math.
+ */
+export declare const parseUnitsValue: (value: unknown, decimals: number) => SolidityIntTypeWrapper;
+/**
+ * Format a sol_int value into a human-readable double.
+ * Mirrors viem/ethers formatUnits behavior.
+ */
+export declare const formatUnitsValue: (value: unknown, decimals: number) => number;
+//# sourceMappingURL=units.d.ts.map

package/dist/units.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"units.d.ts","sourceRoot":"","sources":["../src/units.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAY,MAAM,yBAAyB,CAAC;AAkC3E;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,GAC3B,OAAO,OAAO,EACd,UAAU,MAAM,KACd,sBAwBF,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,OAAO,EAAE,UAAU,MAAM,KAAG,MAOnE,CAAC"}

package/dist/units.js

@@ -0,0 +1,55 @@
+import { SolidityIntTypeWrapper, toBigInt } from "./custom-types/index.js";
+const parseDecimalString = (value, decimals, scale) => {
+    const negative = value.startsWith("-");
+    const abs = negative ? value.slice(1) : value;
+    const parts = abs.split(".");
+    if (parts.length > 2) {
+        throw new TypeError(`parseUnits: invalid decimal string: "${value}"`);
+    }
+    const wholePart = parts[0] ?? "0";
+    const fracPart = parts[1] ?? "";
+    if (fracPart.length > decimals) {
+        throw new TypeError(`parseUnits: fractional part "${fracPart}" exceeds ${String(decimals)} decimals`);
+    }
+    const whole = BigInt(wholePart) * scale;
+    const frac = fracPart.length > 0 ? BigInt(fracPart.padEnd(decimals, "0")) : 0n;
+    const result = whole + frac;
+    return new SolidityIntTypeWrapper(negative ? -result : result);
+};
+/**
+ * Parse a human-readable value into a scaled sol_int.
+ * Mirrors viem/ethers parseUnits behavior.
+ *
+ * Accepts: bigint, number (int or float), string (decimal notation), SolidityIntTypeWrapper.
+ * Floats are converted to string first to avoid floating-point math.
+ */
+export const parseUnitsValue = (value, decimals) => {
+    const scale = 10n ** BigInt(decimals);
+    if (value instanceof SolidityIntTypeWrapper) {
+        return new SolidityIntTypeWrapper(value.value * scale);
+    }
+    if (typeof value === "bigint") {
+        return new SolidityIntTypeWrapper(value * scale);
+    }
+    if (typeof value === "number") {
+        if (Number.isInteger(value)) {
+            return new SolidityIntTypeWrapper(BigInt(value) * scale);
+        }
+        return parseUnitsValue(String(value), decimals);
+    }
+    if (typeof value === "string") {
+        return parseDecimalString(value, decimals, scale);
+    }
+    throw new TypeError(`parseUnits: unsupported value type: ${typeof value}`);
+};
+/**
+ * Format a sol_int value into a human-readable double.
+ * Mirrors viem/ethers formatUnits behavior.
+ */
+export const formatUnitsValue = (value, decimals) => {
+    const raw = toBigInt(value);
+    const scale = 10n ** BigInt(decimals);
+    const whole = raw / scale;
+    const remainder = raw % scale;
+    return Number(whole) + Number(remainder) / Number(scale);
+};

package/dist/units.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=units.spec.d.ts.map

package/dist/units.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"units.spec.d.ts","sourceRoot":"","sources":["../src/units.spec.ts"],"names":[],"mappings":""}

package/dist/units.spec.js

@@ -0,0 +1,77 @@
+import { describe, expect, it } from "vitest";
+import { SolidityIntTypeWrapper } from "./custom-types/index.js";
+import { parseUnitsValue, formatUnitsValue } from "./units.js";
+describe("parseUnitsValue", () => {
+    it("scales a bigint by decimals", () => {
+        expect(parseUnitsValue(1000n, 6)).toEqual(new SolidityIntTypeWrapper(1000000000n));
+    });
+    it("scales an integer number by decimals", () => {
+        expect(parseUnitsValue(1000, 6)).toEqual(new SolidityIntTypeWrapper(1000000000n));
+    });
+    it("parses a decimal string", () => {
+        expect(parseUnitsValue("1.5", 18)).toEqual(new SolidityIntTypeWrapper(1500000000000000000n));
+    });
+    it("parses a whole-number string", () => {
+        expect(parseUnitsValue("1000", 6)).toEqual(new SolidityIntTypeWrapper(1000000000n));
+    });
+    it("parses a string with trailing zeros in fraction", () => {
+        expect(parseUnitsValue("1.50", 18)).toEqual(new SolidityIntTypeWrapper(1500000000000000000n));
+    });
+    it("handles zero values", () => {
+        expect(parseUnitsValue(0, 18)).toEqual(new SolidityIntTypeWrapper(0n));
+        expect(parseUnitsValue("0", 18)).toEqual(new SolidityIntTypeWrapper(0n));
+        expect(parseUnitsValue("0.0", 18)).toEqual(new SolidityIntTypeWrapper(0n));
+    });
+    it("handles double input by converting to string first", () => {
+        expect(parseUnitsValue(1.5, 18)).toEqual(new SolidityIntTypeWrapper(1500000000000000000n));
+    });
+    it("handles SolidityIntTypeWrapper input", () => {
+        const input = new SolidityIntTypeWrapper(1000n);
+        expect(parseUnitsValue(input, 6)).toEqual(new SolidityIntTypeWrapper(1000000000n));
+    });
+    it("throws when fractional part exceeds decimals", () => {
+        expect(() => parseUnitsValue("1.1234567", 6)).toThrow("exceeds");
+    });
+    it("handles zero decimals with integer", () => {
+        expect(parseUnitsValue(1000, 0)).toEqual(new SolidityIntTypeWrapper(1000n));
+    });
+    it("throws for zero decimals with fractional string", () => {
+        expect(() => parseUnitsValue("1.5", 0)).toThrow("exceeds");
+    });
+    it("throws for unsupported types", () => {
+        expect(() => parseUnitsValue(true, 6)).toThrow("unsupported");
+    });
+    it("throws for invalid decimal string", () => {
+        expect(() => parseUnitsValue("1.2.3", 6)).toThrow("invalid");
+    });
+    it("parses a negative decimal string", () => {
+        expect(parseUnitsValue("-1.5", 18)).toEqual(new SolidityIntTypeWrapper(-1500000000000000000n));
+    });
+    it("parses a negative whole-number string", () => {
+        expect(parseUnitsValue("-1000", 6)).toEqual(new SolidityIntTypeWrapper(-1000000000n));
+    });
+    it("parses a negative double input", () => {
+        expect(parseUnitsValue(-1.5, 18)).toEqual(new SolidityIntTypeWrapper(-1500000000000000000n));
+    });
+    it("handles negative bigint input", () => {
+        expect(parseUnitsValue(-1000n, 6)).toEqual(new SolidityIntTypeWrapper(-1000000000n));
+    });
+});
+describe("formatUnitsValue", () => {
+    it("formats a bigint with decimals", () => {
+        expect(formatUnitsValue(1000000000n, 6)).toBe(1000);
+    });
+    it("formats a fractional result", () => {
+        expect(formatUnitsValue(1500000000000000000n, 18)).toBe(1.5);
+    });
+    it("formats zero", () => {
+        expect(formatUnitsValue(0n, 18)).toBe(0);
+    });
+    it("formats a SolidityIntTypeWrapper", () => {
+        const input = new SolidityIntTypeWrapper(1000000n);
+        expect(formatUnitsValue(input, 6)).toBe(1);
+    });
+    it("handles zero decimals", () => {
+        expect(formatUnitsValue(1000n, 0)).toBe(1000);
+    });
+});

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@seljs/types",
+  "version": "1.0.0",
+  "license": "Apache-2.0",
+  "author": {
+    "name": "abi group GmbH",
+    "email": "info@abigroup.io",
+    "url": "https://abigroup.io/"
+  },
+  "repository": {
+    "url": "https://github.com/abinnovision/seljs"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "LICENSE.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "format:check": "prettier --check '{{src,test}/**/*,*}.{{t,j}s{,x},json{,5},md,y{,a}ml}'",
+    "format:fix": "prettier --write '{{src,test}/**/*,*}.{{t,j}s{,x},json{,5},md,y{,a}ml}'",
+    "lint:check": "eslint '{{src,test}/**/*,*}.{t,j}s{,x}'",
+    "lint:fix": "eslint '{{src,test}/**/*,*}.{t,j}s{,x}' --fix",
+    "test-unit": "vitest run",
+    "test-unit:watch": "vitest watch",
+    "typecheck": "tsc --noEmit"
+  },
+  "lint-staged": {
+    "{{src,test}/**/*,*}.{{t,j}s{,x},json{,5},md,y{,a}ml}": [
+      "prettier --write"
+    ],
+    "{{src,test}/**/*,*}.{t,j}s{,x}": [
+      "eslint --fix"
+    ]
+  },
+  "dependencies": {
+    "@seljs/common": "1.0.0"
+  },
+  "devDependencies": {
+    "@abinnovision/eslint-config-base": "^3.2.0",
+    "@abinnovision/prettier-config": "^2.1.5",
+    "@seljs-internal/tsconfig": "^0.0.0",
+    "abitype": "^1.2.3",
+    "eslint": "^9.39.4",
+    "prettier": "^3.8.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "publishConfig": {
+    "npm": true,
+    "npmAccess": "public"
+  }
+}