@seljs/types 1.0.0 → 1.0.1-beta.9

package/dist/registry.js

@@ -1,58 +0,0 @@
-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

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

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

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

package/dist/registry.spec.js

@@ -1,57 +0,0 @@
-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.map

@@ -1 +0,0 @@
-{"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

@@ -1,55 +0,0 @@
-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

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

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

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

package/dist/units.spec.js

@@ -1,77 +0,0 @@
-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);
-    });
-});