@seljs/env 1.0.0 → 1.0.1-beta.9

package/dist/builder.cjs

@@ -0,0 +1,220 @@
+const require_builtins = require("./builtins.cjs");
+let _seljs_common = require("@seljs/common");
+let _seljs_types = require("@seljs/types");
+//#region src/builder.ts
+/**
+* Checks if the given ABI parameter is a tuple type with components, indicating that it represents a struct in Solidity.
+* @param param
+*/
+const isTupleParam = (param) => param.type === "tuple" && "components" in param;
+/**
+* Checks if the given ABI parameter is an array of tuples with components, indicating that it represents an array of structs in Solidity.
+* @param param
+*/
+const isTupleArrayParam = (param) => param.type === "tuple[]" && "components" in param;
+/**
+* Checks if the given ABI parameter is either a tuple or an array of tuples, both of which indicate the presence of components and thus represent struct types in Solidity.
+*
+* @param param
+*/
+const isAnyTupleParam = (param) => isTupleParam(param) || isTupleArrayParam(param);
+/**
+* Generates a unique type name for a nested struct based on the parent type name and the field name, used for naming struct types in the SEL schema.
+*
+* @param parentTypeName Name of the parent type (e.g., contract name or parent struct name) to which the field belongs, used as a prefix for the nested struct type name.
+* @param fieldName Name of the field for which to generate the nested struct type name, used as a suffix in the nested struct type name.
+*/
+const nestedTypeName = (parentTypeName, fieldName) => `${parentTypeName}__${fieldName}`;
+/**
+* Recursively builds struct field definitions.
+*
+* @param components Array of ABI parameters representing the components of a tuple type.
+* @param parentTypeName Name to use for the struct type representing the current level of nesting.
+*/
+const buildStructFields = (components, parentTypeName) => {
+	const fields = {};
+	const nestedTypes = [];
+	for (const component of components) {
+		const fieldName = component.name ?? "arg0";
+		if (isTupleParam(component) && component.components.length > 0) {
+			const childTypeName = nestedTypeName(parentTypeName, fieldName);
+			const child = buildStructFields(component.components, childTypeName);
+			nestedTypes.push(...child.nestedTypes);
+			nestedTypes.push({
+				typeName: childTypeName,
+				fields: child.fields
+			});
+			fields[fieldName] = childTypeName;
+			continue;
+		}
+		if (isTupleArrayParam(component) && component.components.length > 0) {
+			const childTypeName = nestedTypeName(parentTypeName, fieldName);
+			const child = buildStructFields(component.components, childTypeName);
+			nestedTypes.push(...child.nestedTypes);
+			nestedTypes.push({
+				typeName: childTypeName,
+				fields: child.fields
+			});
+			fields[fieldName] = `list<${childTypeName}>`;
+			continue;
+		}
+		fields[fieldName] = (0, _seljs_types.mapSolidityTypeToCEL)(component.type) ?? "dyn";
+	}
+	return {
+		fields,
+		nestedTypes
+	};
+};
+/**
+* Builds method parameters for a given array of ABI parameters.
+*
+* @param inputs Array of ABI parameters representing the inputs of a function.
+*/
+const buildMethodParams = (inputs) => {
+	return inputs.map((param, index) => ({
+		name: param.name || `arg${String(index)}`,
+		type: (0, _seljs_types.mapSolidityTypeToCEL)(param.type) ?? "dyn"
+	}));
+};
+/**
+* Builds the return type resolution for a method based on its ABI components, handling nested structs as needed.
+*
+* @param components Array of ABI parameters representing the components of a tuple return type.
+* @param typeName Name to use for the struct type representing the return value, used for naming nested struct types as well.
+*/
+const buildStructReturn = (components, typeName) => {
+	const result = buildStructFields(components, typeName);
+	const structTypes = [];
+	for (const nested of result.nestedTypes) structTypes.push({
+		name: nested.typeName,
+		kind: "struct",
+		fields: Object.entries(nested.fields).map(([name, type]) => ({
+			name,
+			type
+		}))
+	});
+	structTypes.push({
+		name: typeName,
+		kind: "struct",
+		fields: Object.entries(result.fields).map(([name, type]) => ({
+			name,
+			type
+		}))
+	});
+	return {
+		returns: typeName,
+		structTypes
+	};
+};
+/**
+* Resolves the return type of method based on its ABI function definition.
+*
+* @param fn ABI function for which to resolve the return type.
+* @param contractName Name of the contract to which the function belongs, used for naming nested struct types.
+*/
+const resolveMethodReturnType = (fn, contractName) => {
+	const firstOutput = fn.outputs[0];
+	if (!firstOutput) return {
+		returns: "dyn",
+		structTypes: []
+	};
+	if (fn.outputs.length === 1 && !isAnyTupleParam(firstOutput)) return {
+		returns: (0, _seljs_types.mapSolidityTypeToCEL)(firstOutput.type) ?? "dyn",
+		structTypes: []
+	};
+	const typeName = (0, _seljs_common.structTypeName)(contractName, fn.name);
+	const isSingleOutput = fn.outputs.length === 1;
+	const isSingleTupleArray = isSingleOutput && isTupleArrayParam(firstOutput);
+	const isSingleTuple = isSingleOutput && isTupleParam(firstOutput);
+	let components;
+	if (isSingleTuple || isSingleTupleArray) components = firstOutput.components;
+	else components = fn.outputs.map((o, i) => ({
+		...o,
+		name: o.name ?? `arg${String(i)}`
+	}));
+	const resolution = buildStructReturn(components, typeName);
+	if (isSingleTupleArray) return {
+		returns: `list<${typeName}>`,
+		structTypes: resolution.structTypes
+	};
+	else return resolution;
+};
+/**
+* Builds a MethodSchema for a given ABI function.
+*
+* @param fn ABI function for which to build the MethodSchema.
+* @param contractName Name of the contract to which the function belongs, used for naming nested struct types.
+* @param acc Accumulator to keep track of seen struct types and collect unique TypeSchemas for nested structs.
+*/
+const buildMethodSchema = (fn, contractName, acc) => {
+	const params = buildMethodParams(fn.inputs);
+	const resolution = resolveMethodReturnType(fn, contractName);
+	for (const st of resolution.structTypes) if (!acc.seen.has(st.name)) {
+		acc.types.push(st);
+		acc.seen.add(st.name);
+	}
+	return {
+		name: fn.name,
+		params,
+		returns: resolution.returns,
+		abi: fn
+	};
+};
+/**
+* Builds a ContractSchema for a given contract by processing its ABI and extracting view/pure functions as methods.
+*
+* @param contractName Name of the contract for which to build the schema.
+* @param input ContractInput containing the ABI and other relevant information for the contract.
+* @param acc Accumulator to keep track of seen struct types and collect unique TypeSchemas for nested structs.
+*/
+const buildContractSchema = (contractName, input, acc) => {
+	const methods = input.abi.filter((item) => item.type === "function" && (item.stateMutability === "view" || item.stateMutability === "pure")).map((fn) => buildMethodSchema(fn, contractName, acc));
+	return {
+		name: contractName,
+		address: input.address,
+		description: input.description,
+		methods
+	};
+};
+/**
+* Resolves a ContextFieldDefinition to its CEL type string.
+*/
+const resolveFieldType = (field) => typeof field === "string" ? field : field.type;
+/**
+* Resolves the optional description from a ContextFieldDefinition.
+*/
+const resolveFieldDescription = (field) => typeof field === "string" ? void 0 : field.description;
+/**
+* Extracts variables from the provided context definition and builds an array of VariableSchema objects.
+*/
+const buildVariablesFromContext = (config) => {
+	if (!config.context) return [];
+	return Object.entries(config.context).map(([name, field]) => ({
+		name,
+		type: resolveFieldType(field),
+		description: resolveFieldDescription(field)
+	}));
+};
+/**
+* Builds a SELSchema based on the provided configuration, which includes contract definitions and an optional context for variables.
+*
+* @param config Configuration object containing contract definitions and an optional context for variables.
+* @returns A SELSchema object representing the schema for the SEL environment.
+*/
+const buildSchema = (config) => {
+	const acc = {
+		seen: /* @__PURE__ */ new Set(),
+		types: []
+	};
+	return {
+		version: "1.0.0",
+		contracts: Object.entries(config.contracts ?? {}).map(([name, input]) => buildContractSchema(name, input, acc)),
+		variables: buildVariablesFromContext(config),
+		types: [...require_builtins.SOLIDITY_PRIMITIVE_TYPES, ...acc.types],
+		functions: require_builtins.CEL_BUILTIN_FUNCTIONS,
+		macros: require_builtins.CEL_BUILTIN_MACROS
+	};
+};
+//#endregion
+exports.buildSchema = buildSchema;
+exports.buildStructFields = buildStructFields;

package/dist/builder.d.cts

@@ -0,0 +1,39 @@
+import { SELSchema } from "@seljs/schema";
+import { ContextDefinition } from "@seljs/types";
+import { AbiParameter } from "abitype";
+import { Abi, Address } from "viem";
+
+//#region src/builder.d.ts
+interface StructTypeDefinition {
+  typeName: string;
+  fields: Record<string, string>;
+}
+interface BuildStructFieldsResult {
+  fields: Record<string, string>;
+  nestedTypes: StructTypeDefinition[];
+}
+/**
+ * Recursively builds struct field definitions.
+ *
+ * @param components Array of ABI parameters representing the components of a tuple type.
+ * @param parentTypeName Name to use for the struct type representing the current level of nesting.
+ */
+declare const buildStructFields: (components: readonly AbiParameter[], parentTypeName: string) => BuildStructFieldsResult;
+interface ContractInput {
+  address: Address;
+  abi: Abi;
+  description?: string;
+}
+interface SchemaBuilderConfig {
+  contracts?: Record<string, ContractInput>;
+  context?: ContextDefinition;
+}
+/**
+ * Builds a SELSchema based on the provided configuration, which includes contract definitions and an optional context for variables.
+ *
+ * @param config Configuration object containing contract definitions and an optional context for variables.
+ * @returns A SELSchema object representing the schema for the SEL environment.
+ */
+declare const buildSchema: (config: SchemaBuilderConfig) => SELSchema;
+//#endregion
+export { BuildStructFieldsResult, ContractInput, SchemaBuilderConfig, StructTypeDefinition, buildSchema, buildStructFields };

package/dist/builder.d.mts

@@ -0,0 +1,39 @@
+import { ContextDefinition } from "@seljs/types";
+import { SELSchema } from "@seljs/schema";
+import { AbiParameter } from "abitype";
+import { Abi, Address } from "viem";
+
+//#region src/builder.d.ts
+interface StructTypeDefinition {
+  typeName: string;
+  fields: Record<string, string>;
+}
+interface BuildStructFieldsResult {
+  fields: Record<string, string>;
+  nestedTypes: StructTypeDefinition[];
+}
+/**
+ * Recursively builds struct field definitions.
+ *
+ * @param components Array of ABI parameters representing the components of a tuple type.
+ * @param parentTypeName Name to use for the struct type representing the current level of nesting.
+ */
+declare const buildStructFields: (components: readonly AbiParameter[], parentTypeName: string) => BuildStructFieldsResult;
+interface ContractInput {
+  address: Address;
+  abi: Abi;
+  description?: string;
+}
+interface SchemaBuilderConfig {
+  contracts?: Record<string, ContractInput>;
+  context?: ContextDefinition;
+}
+/**
+ * Builds a SELSchema based on the provided configuration, which includes contract definitions and an optional context for variables.
+ *
+ * @param config Configuration object containing contract definitions and an optional context for variables.
+ * @returns A SELSchema object representing the schema for the SEL environment.
+ */
+declare const buildSchema: (config: SchemaBuilderConfig) => SELSchema;
+//#endregion
+export { BuildStructFieldsResult, ContractInput, SchemaBuilderConfig, StructTypeDefinition, buildSchema, buildStructFields };

package/dist/builder.mjs

@@ -0,0 +1,219 @@
+import { CEL_BUILTIN_FUNCTIONS, CEL_BUILTIN_MACROS, SOLIDITY_PRIMITIVE_TYPES } from "./builtins.mjs";
+import { structTypeName } from "@seljs/common";
+import { mapSolidityTypeToCEL } from "@seljs/types";
+//#region src/builder.ts
+/**
+* Checks if the given ABI parameter is a tuple type with components, indicating that it represents a struct in Solidity.
+* @param param
+*/
+const isTupleParam = (param) => param.type === "tuple" && "components" in param;
+/**
+* Checks if the given ABI parameter is an array of tuples with components, indicating that it represents an array of structs in Solidity.
+* @param param
+*/
+const isTupleArrayParam = (param) => param.type === "tuple[]" && "components" in param;
+/**
+* Checks if the given ABI parameter is either a tuple or an array of tuples, both of which indicate the presence of components and thus represent struct types in Solidity.
+*
+* @param param
+*/
+const isAnyTupleParam = (param) => isTupleParam(param) || isTupleArrayParam(param);
+/**
+* Generates a unique type name for a nested struct based on the parent type name and the field name, used for naming struct types in the SEL schema.
+*
+* @param parentTypeName Name of the parent type (e.g., contract name or parent struct name) to which the field belongs, used as a prefix for the nested struct type name.
+* @param fieldName Name of the field for which to generate the nested struct type name, used as a suffix in the nested struct type name.
+*/
+const nestedTypeName = (parentTypeName, fieldName) => `${parentTypeName}__${fieldName}`;
+/**
+* Recursively builds struct field definitions.
+*
+* @param components Array of ABI parameters representing the components of a tuple type.
+* @param parentTypeName Name to use for the struct type representing the current level of nesting.
+*/
+const buildStructFields = (components, parentTypeName) => {
+	const fields = {};
+	const nestedTypes = [];
+	for (const component of components) {
+		const fieldName = component.name ?? "arg0";
+		if (isTupleParam(component) && component.components.length > 0) {
+			const childTypeName = nestedTypeName(parentTypeName, fieldName);
+			const child = buildStructFields(component.components, childTypeName);
+			nestedTypes.push(...child.nestedTypes);
+			nestedTypes.push({
+				typeName: childTypeName,
+				fields: child.fields
+			});
+			fields[fieldName] = childTypeName;
+			continue;
+		}
+		if (isTupleArrayParam(component) && component.components.length > 0) {
+			const childTypeName = nestedTypeName(parentTypeName, fieldName);
+			const child = buildStructFields(component.components, childTypeName);
+			nestedTypes.push(...child.nestedTypes);
+			nestedTypes.push({
+				typeName: childTypeName,
+				fields: child.fields
+			});
+			fields[fieldName] = `list<${childTypeName}>`;
+			continue;
+		}
+		fields[fieldName] = mapSolidityTypeToCEL(component.type) ?? "dyn";
+	}
+	return {
+		fields,
+		nestedTypes
+	};
+};
+/**
+* Builds method parameters for a given array of ABI parameters.
+*
+* @param inputs Array of ABI parameters representing the inputs of a function.
+*/
+const buildMethodParams = (inputs) => {
+	return inputs.map((param, index) => ({
+		name: param.name || `arg${String(index)}`,
+		type: mapSolidityTypeToCEL(param.type) ?? "dyn"
+	}));
+};
+/**
+* Builds the return type resolution for a method based on its ABI components, handling nested structs as needed.
+*
+* @param components Array of ABI parameters representing the components of a tuple return type.
+* @param typeName Name to use for the struct type representing the return value, used for naming nested struct types as well.
+*/
+const buildStructReturn = (components, typeName) => {
+	const result = buildStructFields(components, typeName);
+	const structTypes = [];
+	for (const nested of result.nestedTypes) structTypes.push({
+		name: nested.typeName,
+		kind: "struct",
+		fields: Object.entries(nested.fields).map(([name, type]) => ({
+			name,
+			type
+		}))
+	});
+	structTypes.push({
+		name: typeName,
+		kind: "struct",
+		fields: Object.entries(result.fields).map(([name, type]) => ({
+			name,
+			type
+		}))
+	});
+	return {
+		returns: typeName,
+		structTypes
+	};
+};
+/**
+* Resolves the return type of method based on its ABI function definition.
+*
+* @param fn ABI function for which to resolve the return type.
+* @param contractName Name of the contract to which the function belongs, used for naming nested struct types.
+*/
+const resolveMethodReturnType = (fn, contractName) => {
+	const firstOutput = fn.outputs[0];
+	if (!firstOutput) return {
+		returns: "dyn",
+		structTypes: []
+	};
+	if (fn.outputs.length === 1 && !isAnyTupleParam(firstOutput)) return {
+		returns: mapSolidityTypeToCEL(firstOutput.type) ?? "dyn",
+		structTypes: []
+	};
+	const typeName = structTypeName(contractName, fn.name);
+	const isSingleOutput = fn.outputs.length === 1;
+	const isSingleTupleArray = isSingleOutput && isTupleArrayParam(firstOutput);
+	const isSingleTuple = isSingleOutput && isTupleParam(firstOutput);
+	let components;
+	if (isSingleTuple || isSingleTupleArray) components = firstOutput.components;
+	else components = fn.outputs.map((o, i) => ({
+		...o,
+		name: o.name ?? `arg${String(i)}`
+	}));
+	const resolution = buildStructReturn(components, typeName);
+	if (isSingleTupleArray) return {
+		returns: `list<${typeName}>`,
+		structTypes: resolution.structTypes
+	};
+	else return resolution;
+};
+/**
+* Builds a MethodSchema for a given ABI function.
+*
+* @param fn ABI function for which to build the MethodSchema.
+* @param contractName Name of the contract to which the function belongs, used for naming nested struct types.
+* @param acc Accumulator to keep track of seen struct types and collect unique TypeSchemas for nested structs.
+*/
+const buildMethodSchema = (fn, contractName, acc) => {
+	const params = buildMethodParams(fn.inputs);
+	const resolution = resolveMethodReturnType(fn, contractName);
+	for (const st of resolution.structTypes) if (!acc.seen.has(st.name)) {
+		acc.types.push(st);
+		acc.seen.add(st.name);
+	}
+	return {
+		name: fn.name,
+		params,
+		returns: resolution.returns,
+		abi: fn
+	};
+};
+/**
+* Builds a ContractSchema for a given contract by processing its ABI and extracting view/pure functions as methods.
+*
+* @param contractName Name of the contract for which to build the schema.
+* @param input ContractInput containing the ABI and other relevant information for the contract.
+* @param acc Accumulator to keep track of seen struct types and collect unique TypeSchemas for nested structs.
+*/
+const buildContractSchema = (contractName, input, acc) => {
+	const methods = input.abi.filter((item) => item.type === "function" && (item.stateMutability === "view" || item.stateMutability === "pure")).map((fn) => buildMethodSchema(fn, contractName, acc));
+	return {
+		name: contractName,
+		address: input.address,
+		description: input.description,
+		methods
+	};
+};
+/**
+* Resolves a ContextFieldDefinition to its CEL type string.
+*/
+const resolveFieldType = (field) => typeof field === "string" ? field : field.type;
+/**
+* Resolves the optional description from a ContextFieldDefinition.
+*/
+const resolveFieldDescription = (field) => typeof field === "string" ? void 0 : field.description;
+/**
+* Extracts variables from the provided context definition and builds an array of VariableSchema objects.
+*/
+const buildVariablesFromContext = (config) => {
+	if (!config.context) return [];
+	return Object.entries(config.context).map(([name, field]) => ({
+		name,
+		type: resolveFieldType(field),
+		description: resolveFieldDescription(field)
+	}));
+};
+/**
+* Builds a SELSchema based on the provided configuration, which includes contract definitions and an optional context for variables.
+*
+* @param config Configuration object containing contract definitions and an optional context for variables.
+* @returns A SELSchema object representing the schema for the SEL environment.
+*/
+const buildSchema = (config) => {
+	const acc = {
+		seen: /* @__PURE__ */ new Set(),
+		types: []
+	};
+	return {
+		version: "1.0.0",
+		contracts: Object.entries(config.contracts ?? {}).map(([name, input]) => buildContractSchema(name, input, acc)),
+		variables: buildVariablesFromContext(config),
+		types: [...SOLIDITY_PRIMITIVE_TYPES, ...acc.types],
+		functions: CEL_BUILTIN_FUNCTIONS,
+		macros: CEL_BUILTIN_MACROS
+	};
+};
+//#endregion
+export { buildSchema, buildStructFields };