@mimicprotocol/cli 0.0.1-rc.10

package/dist/lib/AbisInterfaceGenerator/AbiTypeConverter.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const capitalize_1 = __importDefault(require("lodash/capitalize"));
+const types_1 = require("../../types");
+const ArrayHandler_1 = __importDefault(require("./ArrayHandler"));
+const TupleHandler_1 = __importDefault(require("./TupleHandler"));
+class AbiTypeConverter {
+    constructor(importManager, tupleDefinitions) {
+        this.importManager = importManager;
+        this.tupleDefinitions = tupleDefinitions;
+        this.abiTypecastMap = this.generateAbiTypecastMap();
+    }
+    mapAbiType(param) {
+        const abiType = param.type;
+        if (ArrayHandler_1.default.isArrayType(abiType))
+            return ArrayHandler_1.default.generateLibTypeArray(param, this.mapAbiType.bind(this));
+        if (TupleHandler_1.default.isBaseTypeATuple(abiType)) {
+            const existingClassName = TupleHandler_1.default.getClassNameForTupleDefinition(param, this.tupleDefinitions);
+            if (existingClassName)
+                return existingClassName;
+            console.warn(`Tuple class name not found by AbiTypeConverter for: ${param.type}, internal: ${param.internalType}. It might be an anonymous or unextracted tuple.`);
+            return 'unknown';
+        }
+        const mapped = this.abiTypecastMap[abiType] || 'unknown';
+        if (mapped === 'unknown')
+            console.warn(`Unknown type: ${param.type}`);
+        if (Object.values(types_1.LibTypes).includes(mapped)) {
+            this.importManager.addType(mapped);
+        }
+        return mapped;
+    }
+    toLibType(paramType, paramName) {
+        if (ArrayHandler_1.default.isArrayType(paramType))
+            return paramName;
+        switch (paramType) {
+            case types_1.AssemblyPrimitiveTypes.bool:
+                this.importManager.addType(types_1.LibTypes.Bytes);
+                return `${types_1.LibTypes.Bytes}.fromBool(${paramName})`;
+            case types_1.AssemblyPrimitiveTypes.i8:
+            case types_1.AssemblyPrimitiveTypes.u8:
+            case types_1.AssemblyPrimitiveTypes.i16:
+            case types_1.AssemblyPrimitiveTypes.u16:
+            case types_1.AssemblyPrimitiveTypes.i32:
+            case types_1.AssemblyPrimitiveTypes.u32:
+            case types_1.AssemblyPrimitiveTypes.i64:
+            case types_1.AssemblyPrimitiveTypes.u64:
+                this.importManager.addType(types_1.LibTypes.BigInt);
+                return `${types_1.LibTypes.BigInt}.from${(0, capitalize_1.default)(paramType)}(${paramName})`;
+            case types_1.AssemblyPrimitiveTypes.string:
+                this.importManager.addType(types_1.LibTypes.Bytes);
+                return `${types_1.LibTypes.Bytes}.fromUTF8(${paramName})`;
+            case types_1.LibTypes.BigInt:
+            case types_1.LibTypes.Address:
+            case types_1.LibTypes.Bytes:
+            default:
+                return paramName;
+        }
+    }
+    generateTypeConversion(type, valueVarName, isMapFunction, includeReturn = true) {
+        let conversion;
+        switch (type) {
+            case types_1.LibTypes.BigInt:
+            case types_1.LibTypes.Address:
+                conversion = `${type}.fromString(${valueVarName})`;
+                break;
+            case types_1.LibTypes.Bytes:
+                conversion = `${type}.fromHexString(${valueVarName})`;
+                break;
+            case types_1.AssemblyPrimitiveTypes.i8:
+            case types_1.AssemblyPrimitiveTypes.u8:
+            case types_1.AssemblyPrimitiveTypes.i16:
+            case types_1.AssemblyPrimitiveTypes.u16:
+            case types_1.AssemblyPrimitiveTypes.i32:
+            case types_1.AssemblyPrimitiveTypes.u32:
+            case types_1.AssemblyPrimitiveTypes.i64:
+            case types_1.AssemblyPrimitiveTypes.u64:
+                conversion = `${type}.parse(${valueVarName})`;
+                break;
+            case types_1.AssemblyPrimitiveTypes.bool:
+                conversion = `${types_1.AssemblyPrimitiveTypes.u8}.parse(${valueVarName}) as ${types_1.AssemblyPrimitiveTypes.bool}`;
+                break;
+            default:
+                conversion = TupleHandler_1.default.isTupleClassName(type, this.tupleDefinitions)
+                    ? `${type}.parse(${valueVarName})`
+                    : valueVarName;
+                break;
+        }
+        return isMapFunction ? `${valueVarName} => ${conversion}` : includeReturn ? `return ${conversion}` : conversion;
+    }
+    generateIntegerTypeMappings() {
+        const mappings = {
+            int8: types_1.AssemblyPrimitiveTypes.i8,
+            uint8: types_1.AssemblyPrimitiveTypes.u8,
+            int16: types_1.AssemblyPrimitiveTypes.i16,
+            uint16: types_1.AssemblyPrimitiveTypes.u16,
+            int32: types_1.AssemblyPrimitiveTypes.i32,
+            uint32: types_1.AssemblyPrimitiveTypes.u32,
+            int64: types_1.AssemblyPrimitiveTypes.i64,
+            uint64: types_1.AssemblyPrimitiveTypes.u64,
+            int: types_1.LibTypes.BigInt,
+            uint: types_1.LibTypes.BigInt,
+        };
+        const START_BITS = 24;
+        const END_BITS = 256;
+        const STEP = 8;
+        for (let bits = START_BITS; bits <= END_BITS; bits += STEP) {
+            if (!mappings[`int${bits}`])
+                mappings[`int${bits}`] = types_1.LibTypes.BigInt;
+            if (!mappings[`uint${bits}`])
+                mappings[`uint${bits}`] = types_1.LibTypes.BigInt;
+        }
+        return mappings;
+    }
+    generateBytesTypeMappings() {
+        const mappings = {
+            bytes: types_1.LibTypes.Bytes,
+        };
+        const MAX_SIZE = 32;
+        for (let size = 1; size <= MAX_SIZE; size++) {
+            mappings[`bytes${size}`] = types_1.LibTypes.Bytes;
+        }
+        return mappings;
+    }
+    generateAbiTypecastMap() {
+        return {
+            ...this.generateIntegerTypeMappings(),
+            ...this.generateBytesTypeMappings(),
+            address: types_1.LibTypes.Address,
+            bool: types_1.AssemblyPrimitiveTypes.bool,
+            string: types_1.AssemblyPrimitiveTypes.string,
+        };
+    }
+}
+exports.default = AbiTypeConverter;

package/dist/lib/AbisInterfaceGenerator/ArrayHandler.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+class ArrayHandler {
+    static isArrayType(abiOrMappedType) {
+        return abiOrMappedType.endsWith(']');
+    }
+    /**
+     * Returns the base type of an array, e.g., "uint256[2][]" -> "uint256[2]".
+     */
+    static getArrayType(type) {
+        if (!this.isArrayType(type))
+            return type;
+        const lastBracket = type.lastIndexOf('[');
+        if (lastBracket === -1)
+            return type;
+        return type.substring(0, lastBracket);
+    }
+    /**
+     * Returns the depth of an array, e.g., "uint256[][]" -> 2.
+     */
+    static getArrayDepth(abiType) {
+        let depth = 0;
+        let tempType = abiType;
+        while (tempType.endsWith(']')) {
+            depth++;
+            const lastBracket = tempType.lastIndexOf('[');
+            if (lastBracket === -1)
+                break;
+            tempType = tempType.substring(0, lastBracket);
+        }
+        return depth;
+    }
+    /**
+     * Returns the  base type of a potentially nested ABI array type string.
+     * E.g., for "uint256[][]", it returns "uint256".
+     */
+    static getBaseType(type) {
+        const bracketIndex = type.indexOf('[');
+        if (bracketIndex === -1)
+            return type;
+        return type.substring(0, bracketIndex);
+    }
+    /**
+     * Gets the mapped type of the  base element of an array.
+     */
+    static baseAbiTypeToLibType(param, mapBaseTypeFunc) {
+        const baseAbiType = this.getBaseType(param.type);
+        const baseParam = {
+            ...param,
+            type: baseAbiType,
+            components: baseAbiType === types_1.TUPLE_ABI_TYPE ? param.components : undefined,
+            internalType: param.internalType ? this.getBaseType(param.internalType) : undefined,
+        };
+        return mapBaseTypeFunc(baseParam);
+    }
+    /**
+     * Constructs the full lib type array string, e.g., "BigInt[][]",
+     * based on the original ABI array type's depth.
+     */
+    static generateLibTypeArray(originalParam, mapBaseTypeFunc) {
+        const mappedBaseType = this.baseAbiTypeToLibType(originalParam, mapBaseTypeFunc);
+        const depth = this.getArrayDepth(originalParam.type);
+        return mappedBaseType + '[]'.repeat(depth);
+    }
+}
+exports.default = ArrayHandler;

package/dist/lib/AbisInterfaceGenerator/ContractClassGenerator.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("../../types");
+const AbiTypeConverter_1 = __importDefault(require("./AbiTypeConverter"));
+const FunctionHandler_1 = __importDefault(require("./FunctionHandler"));
+const ImportManager_1 = __importDefault(require("./ImportManager"));
+const NameManager_1 = __importDefault(require("./NameManager"));
+const TupleHandler_1 = __importDefault(require("./TupleHandler"));
+class ContractClassGenerator {
+    constructor(abi) {
+        this.abi = abi;
+        this.importManager = new ImportManager_1.default();
+        this.tupleDefinitions = TupleHandler_1.default.extractTupleDefinitions(this.abi);
+        this.abiTypeConverter = new AbiTypeConverter_1.default(this.importManager, this.tupleDefinitions);
+    }
+    generate(contractName) {
+        const mainClassCode = this.generateMainClass(contractName);
+        const tupleClassesCode = TupleHandler_1.default.generateTupleClassesCode(this.tupleDefinitions, this.importManager, this.abiTypeConverter);
+        // Note: this should be generated after any other generation
+        const importsCode = this.importManager.generateImportsCode();
+        const notice = '// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE MANUALLY.';
+        const separator = '\n\n';
+        let result = notice + separator + importsCode + separator + mainClassCode;
+        if (tupleClassesCode)
+            result += separator + tupleClassesCode;
+        return result.trim();
+    }
+    generateMainClass(contractName) {
+        const lines = [];
+        this.appendClassDefinition(lines, contractName);
+        const functions = NameManager_1.default.resolveMethodNames(this.getFunctions());
+        functions.forEach((fn) => FunctionHandler_1.default.appendMethod(lines, fn, this.importManager, this.tupleDefinitions, this.abiTypeConverter));
+        lines.push('}');
+        return lines.join('\n');
+    }
+    appendClassDefinition(lines, contractName) {
+        this.importManager.addType(types_1.LibTypes.Address);
+        this.importManager.addType(types_1.LibTypes.ChainId);
+        lines.push(`export class ${contractName} {`);
+        lines.push(`  private _address: ${types_1.LibTypes.Address}`);
+        lines.push(`  private _chainId: ${types_1.LibTypes.ChainId}`);
+        lines.push(`  private _timestamp: ${types_1.AssemblyPrimitiveTypes.Date} | null`);
+        lines.push('');
+        lines.push(`  constructor(address: ${types_1.LibTypes.Address}, chainId: ${types_1.LibTypes.ChainId}, timestamp: ${types_1.AssemblyPrimitiveTypes.Date} | null = null) {`);
+        lines.push(`    this._address = address`);
+        lines.push(`    this._chainId = chainId`);
+        lines.push(`    this._timestamp = timestamp`);
+        lines.push(`  }`);
+        lines.push('');
+        lines.push(`  get address(): ${types_1.LibTypes.Address} {`);
+        lines.push(`    return this._address.clone()`);
+        lines.push(`  }`);
+        lines.push('');
+        lines.push(`  get chainId(): ${types_1.LibTypes.ChainId} {`);
+        lines.push(`    return this._chainId`);
+        lines.push(`  }`);
+        lines.push('');
+        lines.push(`  get timestamp(): ${types_1.AssemblyPrimitiveTypes.Date} | null {`);
+        lines.push(`    return this._timestamp ? new ${types_1.AssemblyPrimitiveTypes.Date}(changetype<${types_1.AssemblyPrimitiveTypes.Date}>(this._timestamp).getTime()) : null`);
+        lines.push(`  }`);
+        lines.push('');
+    }
+    getFunctions() {
+        return this.abi.filter((item) => item.type === 'function');
+    }
+}
+exports.default = ContractClassGenerator;

package/dist/lib/AbisInterfaceGenerator/FunctionHandler.js

@@ -0,0 +1,173 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("../../helpers");
+const types_1 = require("../../types");
+const ArrayHandler_1 = __importDefault(require("./ArrayHandler"));
+const NameManager_1 = __importStar(require("./NameManager"));
+const TupleHandler_1 = __importDefault(require("./TupleHandler"));
+const types_2 = require("./types");
+class FunctionHandler {
+    static appendMethod(lines, fn, importManager, tupleDefinitions, abiTypeConverter) {
+        const inputs = NameManager_1.default.resolveParameterNames(fn.inputs || [], NameManager_1.NameContext.FUNCTION_PARAMETER, 'param');
+        const methodParams = this.generateMethodParams(inputs, abiTypeConverter);
+        const returnType = this.getReturnType(fn, tupleDefinitions, abiTypeConverter);
+        const methodName = fn.escapedName || fn.name;
+        lines.push(`  ${methodName}(${methodParams}): ${returnType} {`);
+        const callArgs = this.generateCallArguments(inputs, importManager, abiTypeConverter);
+        this.appendFunctionBody(lines, fn, returnType, callArgs, importManager, abiTypeConverter);
+        lines.push(`  }`);
+        lines.push('');
+    }
+    static getReturnType(fn, tupleDefinitions, abiTypeConverter) {
+        if (this.isWriteFunction(fn))
+            return 'CallBuilder';
+        if (!fn.outputs || fn.outputs.length === 0)
+            return 'void';
+        if (fn.outputs.length === 1)
+            return abiTypeConverter.mapAbiType(fn.outputs[0]);
+        const name = TupleHandler_1.default.getOutputTupleClassName(fn.name);
+        const representativeOutputTuple = {
+            name,
+            type: types_2.TUPLE_ABI_TYPE,
+            internalType: `struct ${name}`,
+            components: fn.outputs,
+        };
+        const tupleClassName = TupleHandler_1.default.getClassNameForTupleDefinition(representativeOutputTuple, tupleDefinitions);
+        if (tupleClassName)
+            return tupleClassName;
+        console.error(`Could not determine tuple class name for outputs of function ${fn.name}`);
+        return 'unknown';
+    }
+    static generateMethodParams(inputs, abiTypeConverter) {
+        return inputs
+            .map((input) => {
+            const paramName = input.escapedName;
+            const type = abiTypeConverter.mapAbiType(input);
+            return `${paramName}: ${type}`;
+        })
+            .join(', ');
+    }
+    static buildEvmEncodeParamCode(valueIdentifier, paramDefinition, abiTypeConverter, importManager, depth = 0) {
+        importManager.addType('EvmEncodeParam');
+        const currentAbiTypeSignature = TupleHandler_1.default.isBaseTypeATuple(paramDefinition.type)
+            ? TupleHandler_1.default.mapTupleType(paramDefinition.type)
+            : paramDefinition.type;
+        if (ArrayHandler_1.default.isArrayType(paramDefinition.type)) {
+            const elementLambdaVar = `s${depth}`;
+            const elementAbiDefinition = {
+                name: elementLambdaVar,
+                type: ArrayHandler_1.default.getArrayType(paramDefinition.type),
+                components: TupleHandler_1.default.isBaseTypeATuple(ArrayHandler_1.default.getArrayType(paramDefinition.type))
+                    ? paramDefinition.components
+                    : undefined,
+                internalType: paramDefinition.internalType
+                    ? ArrayHandler_1.default.getArrayType(paramDefinition.internalType)
+                    : undefined,
+            };
+            const nestedEvmParam = FunctionHandler.buildEvmEncodeParamCode(elementLambdaVar, elementAbiDefinition, abiTypeConverter, importManager, depth + 1);
+            return `EvmEncodeParam.fromValues('${currentAbiTypeSignature}', ${valueIdentifier}.map<EvmEncodeParam>((${elementLambdaVar}) => ${nestedEvmParam}))`;
+        }
+        if (TupleHandler_1.default.isBaseTypeATuple(paramDefinition.type)) {
+            return `EvmEncodeParam.fromValues('${currentAbiTypeSignature}', ${valueIdentifier}.toEvmEncodeParams())`;
+        }
+        const mappedParamType = abiTypeConverter.mapAbiType(paramDefinition);
+        const convertedValue = abiTypeConverter.toLibType(mappedParamType, valueIdentifier);
+        return `EvmEncodeParam.fromValue('${currentAbiTypeSignature}', ${convertedValue})`;
+    }
+    static generateCallArguments(inputs, importManager, abiTypeConverter) {
+        return inputs
+            .map((input) => {
+            const paramName = input.escapedName;
+            return FunctionHandler.buildEvmEncodeParamCode(paramName, input, abiTypeConverter, importManager, 0);
+        })
+            .join(', ');
+    }
+    static getDecodeAbiType(fn) {
+        const outputs = fn.outputs ?? [];
+        if (outputs.length === 0)
+            return '()';
+        if (outputs.length === 1) {
+            const [output] = outputs;
+            const { type, components } = output;
+            if (TupleHandler_1.default.isBaseTypeATuple(type) && components)
+                return TupleHandler_1.default.generateTupleTypeString(type, components);
+            return type;
+        }
+        return TupleHandler_1.default.generateTupleTypeString(types_2.TUPLE_ABI_TYPE, outputs);
+    }
+    static getReturnExpression(currentType, dataAccessString, importManager, abiTypeConverter, depth = 0) {
+        if (ArrayHandler_1.default.isArrayType(currentType)) {
+            importManager.addType('JSON');
+            const elementType = ArrayHandler_1.default.getArrayType(currentType);
+            const itemVar = `item${depth}`;
+            const subLogic = this.getReturnExpression(elementType, itemVar, importManager, abiTypeConverter, depth + 1);
+            return `${dataAccessString} === '' ? [] : JSON.parse<${types_1.AssemblyPrimitiveTypes.string}[]>(${dataAccessString}).map<${elementType}>(((${itemVar}: ${types_1.AssemblyPrimitiveTypes.string}) => ${subLogic}))`;
+        }
+        return abiTypeConverter.generateTypeConversion(currentType, dataAccessString, false, false);
+    }
+    static appendFunctionBody(lines, fn, returnType, callArgs, importManager, abiTypeConverter) {
+        const selector = (0, helpers_1.getFunctionSelector)(fn);
+        if (callArgs)
+            importManager.addType('evm');
+        const encodedCall = `'${selector}'${callArgs ? ` + evm.encode([${callArgs}])` : ''}`;
+        if (this.isWriteFunction(fn)) {
+            importManager.addType(types_1.LibTypes.Bytes);
+            importManager.addType('CallBuilder');
+            lines.push(`    const encodedData = Bytes.fromHexString(${encodedCall})`);
+            lines.push(`    return CallBuilder.forChain(this._chainId).addCall(this._address, encodedData)`);
+            return;
+        }
+        importManager.addType('environment');
+        const contractCallCode = `environment.contractCall(this._address, this._chainId, this._timestamp, ${encodedCall})`;
+        if (returnType === 'void') {
+            lines.push(`    ${contractCallCode}`);
+            return;
+        }
+        importManager.addType('EvmDecodeParam');
+        const decodeAbiType = this.getDecodeAbiType(fn);
+        lines.push(`    const response = ${contractCallCode}`);
+        lines.push(`    const decodedResponse = evm.decode(new EvmDecodeParam('${decodeAbiType}', response))`);
+        const returnExpression = this.getReturnExpression(returnType, 'decodedResponse', importManager, abiTypeConverter);
+        lines.push(`    return ${returnExpression}`);
+    }
+    static isWriteFunction(fn) {
+        return ['nonpayable', 'payable'].includes(fn.stateMutability || '');
+    }
+}
+exports.default = FunctionHandler;

package/dist/lib/AbisInterfaceGenerator/ImportManager.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ImportManager {
+    constructor() {
+        this.types = new Set();
+    }
+    addType(type) {
+        this.types.add(type);
+    }
+    generateImportsCode() {
+        if (this.types.size === 0)
+            return '';
+        const sortedTypes = [...this.types].sort((a, b) => String(a).localeCompare(String(b)));
+        return `import { ${sortedTypes.join(', ')} } from '@mimicprotocol/lib-ts'`;
+    }
+}
+exports.default = ImportManager;

package/dist/lib/AbisInterfaceGenerator/NameManager.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NameContext = void 0;
+var NameContext;
+(function (NameContext) {
+    NameContext["FUNCTION_PARAMETER"] = "function_parameter";
+    NameContext["LOCAL_VARIABLE"] = "local_variable";
+    NameContext["CLASS_PROPERTY"] = "class_property";
+    NameContext["METHOD_NAME"] = "method_name";
+})(NameContext || (exports.NameContext = NameContext = {}));
+class NameManager {
+    static resolveNameConflicts(names, context) {
+        const usedNames = new Set();
+        return names.map((originalName) => {
+            let escapedName = this.escapeName(originalName, context);
+            let counter = 1;
+            while (usedNames.has(escapedName)) {
+                const suffix = this.getSuffixForContext(context);
+                escapedName = `${originalName}${suffix}${counter}`;
+                counter++;
+            }
+            usedNames.add(escapedName);
+            return escapedName;
+        });
+    }
+    static resolveParameterNames(parameters, context, defaultPrefix = 'param') {
+        const originalNames = parameters.map((param, index) => param.name && param.name.length > 0 ? param.name : `${defaultPrefix}${index}`);
+        const resolvedNames = this.resolveNameConflicts(originalNames, context);
+        return parameters.map((param, index) => ({
+            ...param,
+            escapedName: resolvedNames[index],
+        }));
+    }
+    static resolveMethodNames(functions) {
+        const methodNames = functions.map((fn) => fn.name);
+        const resolvedNames = this.resolveNameConflicts(methodNames, NameContext.METHOD_NAME);
+        return functions.map((fn, index) => ({
+            ...fn,
+            escapedName: resolvedNames[index],
+        }));
+    }
+    static hasConflict(name, context) {
+        if (this.RESERVED_BY_CONTEXT[context]?.has(name))
+            return true;
+        return this.INTERNAL_NAME_PATTERNS.some((pattern) => pattern.test(name));
+    }
+    static escapeName(name, context) {
+        if (!this.hasConflict(name, context))
+            return name;
+        const suffix = this.getSuffixForContext(context);
+        let escapedName = `${name}${suffix}`;
+        let counter = 1;
+        while (this.hasConflict(escapedName, context)) {
+            escapedName = `${name}${suffix}${counter}`;
+            counter++;
+        }
+        return escapedName;
+    }
+    static getSuffixForContext(context) {
+        switch (context) {
+            case NameContext.FUNCTION_PARAMETER:
+                return '_param';
+            case NameContext.LOCAL_VARIABLE:
+                return '_var';
+            case NameContext.CLASS_PROPERTY:
+                return '_prop';
+            case NameContext.METHOD_NAME:
+                return '_';
+            default:
+                return '_safe';
+        }
+    }
+}
+NameManager.RESERVED_BY_CONTEXT = {
+    [NameContext.FUNCTION_PARAMETER]: new Set([
+        'response',
+        'decodedResponse',
+        'selector',
+        'callArgs',
+        'contractCallCode',
+        'inputs',
+        'methodParams',
+        'returnType',
+        'lines',
+    ]),
+    [NameContext.LOCAL_VARIABLE]: new Set(['data', 'parts', 'response', 'decodedResponse', 'selector', 'encodedData']),
+    [NameContext.CLASS_PROPERTY]: new Set([
+        'constructor',
+        'parse',
+        'toEvmEncodeParams',
+        'address',
+        'chainId',
+        'timestamp',
+    ]),
+    [NameContext.METHOD_NAME]: new Set(['constructor']),
+};
+NameManager.INTERNAL_NAME_PATTERNS = [/^item\d+$/, /^s\d+$/];
+exports.default = NameManager;