@snovon/solast 0.2.0

package/dist/detectors/delegatecall-init.js

@@ -0,0 +1,769 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelegatecallInitDetector = void 0;
+const RULE_ID = 'delegatecall-init';
+const SOURCE = 'x-20170719-parity-multisig';
+const INIT_FUNCTION_NAMES = new Set(['init', 'initialize', 'setup']);
+const OWNER_STORAGE_NAMES = /^(isOwner|owner|owners|ownerCount|admin|admins|authority|governance|governor)$/i;
+const ACCESS_CONTROL_MODIFIERS = new Set([
+    'onlyowner',
+    'onlyrole',
+    'onlyadmin',
+    'onlyauthorized',
+    'onlyoperator',
+    'onlygovernance',
+    'onlygovernor',
+    'onlyguardian',
+    'onlymanager',
+]);
+const ONE_TIME_GUARD_MODIFIERS = new Set([
+    'initializer',
+    'reinitializer',
+    'onlyonce',
+    'oncedonly',
+    'noninitialized',
+    'whennotinitialized',
+]);
+class DelegatecallInitDetector {
+    id = RULE_ID;
+    patternKey = RULE_ID;
+    supportedAstKinds = ['parser', 'solc'];
+    scanAst(ast, file, sourceText) {
+        if (!ast || typeof ast !== 'object')
+            return [];
+        const findings = [];
+        const lineOffsets = buildLineOffsets(sourceText);
+        const contracts = collectContracts(ast)
+            .filter(contractNode => !isInterfaceLike(contractNode))
+            .map(contractNode => buildContractInfo(contractNode));
+        const contractsByName = new Map(contracts.map(contract => [contract.name, contract]));
+        const initCandidates = collectInitCandidates(contracts);
+        const delegatecalls = collectDelegatecallPaths(contracts);
+        const emitted = new Set();
+        for (const call of delegatecalls) {
+            for (const candidate of matchingInitCandidates(call, initCandidates, contractsByName)) {
+                const key = `${call.callerContract.name}.${call.caller.name}:${call.target}:${candidate.contract.name}.${candidate.fn.name}`;
+                if (emitted.has(key))
+                    continue;
+                emitted.add(key);
+                const loc = getLoc(call.node, lineOffsets) || getLoc(call.caller.node, lineOffsets) || { line: 0, column: 0 };
+                const callerName = `${call.callerContract.name}.${call.caller.name}`;
+                const initializerPath = candidate.path.map(name => `${candidate.contract.name}.${name}`).join(' -> ');
+                findings.push({
+                    file,
+                    contract: call.callerContract.name,
+                    'function': call.caller.name,
+                    line: loc.line,
+                    endLine: loc.line,
+                    column: loc.column,
+                    pattern: RULE_ID,
+                    confidence: 'high',
+                    ruleId: RULE_ID,
+                    severity: 'critical',
+                    message: `Externally reachable delegatecall in '${callerName}' can invoke unprotected initializer path '${initializerPath}' through target '${call.target}'.`,
+                    rationale: 'Mirrors the 2017-07-19 Parity multisig hack: a proxy-style caller forwards data by delegatecall to initialization logic that overwrites privileged ownership storage without an effective one-time initialization guard.',
+                    suggestedFix: 'Guard the initializer with an OpenZeppelin `initializer`/`reinitializer` modifier or an explicit initialized-state check that is set during initialization, and restrict public delegatecall forwarding to trusted callers/selectors.',
+                    contractName: call.callerContract.name,
+                    functionName: call.caller.name,
+                    sourceLocation: { line: loc.line, column: loc.column },
+                    caller: callerName,
+                    delegateTarget: call.target,
+                    initializerPath,
+                    trace: `caller: ${callerName}; delegate target: ${call.target}; initializer path: ${initializerPath}`,
+                    operationType: 'delegatecall',
+                    externalCallNode: call.node,
+                    findingId: '',
+                    contractHash: '',
+                    source: SOURCE,
+                });
+            }
+        }
+        return findings;
+    }
+}
+exports.DelegatecallInitDetector = DelegatecallInitDetector;
+function isCanonicalInitName(name) {
+    if (!name)
+        return false;
+    const normalized = name.toLowerCase();
+    return INIT_FUNCTION_NAMES.has(normalized) || normalized.startsWith('init');
+}
+function buildContractInfo(contractNode) {
+    const ownerNames = collectOwnerStateNames(contractNode);
+    const functions = new Map();
+    for (const fn of getContractFunctions(contractNode)) {
+        const name = functionDisplayName(fn);
+        const body = getFunctionBody(fn);
+        functions.set(name, {
+            node: fn,
+            name,
+            directMutation: !!body && bodyMutatesOwnerStorage(body, ownerNames),
+            calls: body ? collectSameContractCalls(body) : new Set(),
+        });
+    }
+    return {
+        node: contractNode,
+        name: getName(contractNode) || '<anonymous>',
+        ownerNames,
+        stateTypes: collectStateVariableTypes(contractNode),
+        functions,
+    };
+}
+function collectInitCandidates(contracts) {
+    const candidates = [];
+    for (const contract of contracts) {
+        if (contract.ownerNames.size === 0)
+            continue;
+        for (const fn of contract.functions.values()) {
+            if (!isCanonicalInitName(fn.name))
+                continue;
+            if (isConstructor(fn.node))
+                continue;
+            if (!isExternallyCallable(fn.node))
+                continue;
+            const body = getFunctionBody(fn.node);
+            if (!body)
+                continue;
+            if (hasEffectiveOneTimeGuard(fn.node, body))
+                continue;
+            if (hasCallerAccessControl(fn.node, body))
+                continue;
+            const path = ownerMutationPath(fn, contract.functions, new Set());
+            if (!path)
+                continue;
+            candidates.push({ contract, fn, path });
+        }
+    }
+    return candidates;
+}
+function collectDelegatecallPaths(contracts) {
+    const paths = [];
+    for (const contract of contracts) {
+        for (const fn of contract.functions.values()) {
+            if (!isExternallyReachableCaller(fn.node))
+                continue;
+            if (hasCallerAccessControl(fn.node, getFunctionBody(fn.node)))
+                continue;
+            collectDelegatecallsFromFunction(contract, fn, contract.functions, new Set(), paths);
+        }
+    }
+    return paths;
+}
+function collectDelegatecallsFromFunction(contract, caller, functions, seen, out) {
+    collectDelegatecallsFromCurrentFunction(contract, caller, caller, functions, seen, out);
+}
+function collectDelegatecallsFromCurrentFunction(contract, externalCaller, current, functions, seen, out) {
+    if (seen.has(current.name))
+        return;
+    seen.add(current.name);
+    const body = getFunctionBody(current.node);
+    if (!body)
+        return;
+    walkAny(body, node => {
+        const delegatecall = delegatecallDetails(node, contract);
+        if (delegatecall) {
+            out.push({ callerContract: contract, caller: externalCaller, node, ...delegatecall });
+        }
+        return false;
+    });
+    for (const calledName of current.calls) {
+        const called = functions.get(calledName);
+        if (called && !isExternallyReachableCaller(called.node)) {
+            collectDelegatecallsFromCurrentFunction(contract, externalCaller, called, functions, seen, out);
+        }
+    }
+}
+function delegatecallDetails(node, contract) {
+    if (!isNode(node, 'FunctionCall'))
+        return undefined;
+    const callee = node.expression;
+    if (!isNode(callee, 'MemberAccess') || String(callee.memberName || '') !== 'delegatecall')
+        return undefined;
+    const targetExpr = callee.expression;
+    const target = expressionToString(targetExpr);
+    return {
+        target,
+        targetType: delegateTargetType(targetExpr, contract),
+        selector: selectorFromDelegatecallArgs(node.arguments || []),
+    };
+}
+function matchingInitCandidates(call, candidates, contractsByName) {
+    const targetResolved = !!(call.targetType && contractsByName.has(call.targetType));
+    if (!targetResolved && !call.selector)
+        return [];
+    let scoped = candidates.filter(candidate => candidate.contract.name !== call.callerContract.name);
+    if (targetResolved) {
+        scoped = scoped.filter(candidate => candidate.contract.name === call.targetType);
+    }
+    if (call.selector) {
+        scoped = scoped.filter(candidate => candidate.fn.name === call.selector);
+    }
+    return scoped;
+}
+function ownerMutationPath(info, functions, seen) {
+    if (info.directMutation)
+        return [info.name];
+    if (seen.has(info.name))
+        return undefined;
+    seen.add(info.name);
+    for (const calledName of info.calls) {
+        const called = functions.get(calledName);
+        if (!called)
+            continue;
+        const tail = ownerMutationPath(called, functions, seen);
+        if (tail)
+            return [info.name, ...tail];
+    }
+    return undefined;
+}
+function collectOwnerStateNames(contractNode) {
+    const result = new Set();
+    for (const child of getContractMembers(contractNode)) {
+        if (isNode(child, 'StateVariableDeclaration')) {
+            for (const v of child.variables || []) {
+                if (v?.name && isPrivilegedStorageName(String(v.name)))
+                    result.add(String(v.name));
+            }
+        }
+        else if (isNode(child, 'VariableDeclaration') && child.stateVariable) {
+            if (child.name && isPrivilegedStorageName(String(child.name)))
+                result.add(String(child.name));
+        }
+    }
+    return result;
+}
+function collectStateVariableTypes(contractNode) {
+    const result = new Map();
+    for (const child of getContractMembers(contractNode)) {
+        if (isNode(child, 'StateVariableDeclaration')) {
+            for (const v of child.variables || []) {
+                if (v?.name) {
+                    const typeName = variableTypeName(v);
+                    if (typeName)
+                        result.set(String(v.name), typeName);
+                }
+            }
+        }
+        else if (isNode(child, 'VariableDeclaration') && child.stateVariable) {
+            const typeName = variableTypeName(child);
+            if (child.name && typeName)
+                result.set(String(child.name), typeName);
+        }
+    }
+    return result;
+}
+function variableTypeName(variable) {
+    const typeName = variable?.typeName;
+    if (!typeName || typeof typeName !== 'object')
+        return '';
+    if (typeof typeName.name === 'string')
+        return typeName.name;
+    if (typeof typeName.namePath === 'string')
+        return typeName.namePath.split('.').pop() || '';
+    if (typeName.pathNode)
+        return variableTypeName({ typeName: typeName.pathNode });
+    if (typeof typeName.typeString === 'string')
+        return typeName.typeString.split(' ').pop() || '';
+    return '';
+}
+function isPrivilegedStorageName(name) {
+    if (!name)
+        return false;
+    const normalized = name.length > 1 && name.startsWith('_') ? name.slice(1) : name;
+    return OWNER_STORAGE_NAMES.test(normalized);
+}
+function bodyMutatesOwnerStorage(body, ownerNames) {
+    return walkAny(body, node => isOwnerAssignment(node, ownerNames) || isOwnerArrayPush(node, ownerNames));
+}
+function isOwnerAssignment(node, ownerNames) {
+    if (!node || typeof node !== 'object')
+        return false;
+    let left = null;
+    if (isNode(node, 'BinaryOperation')) {
+        const operator = String(node.operator || '');
+        if (!operator.includes('=') || ['==', '===', '!=', '!==', '<=', '>='].includes(operator))
+            return false;
+        left = node.left || node.leftExpression;
+    }
+    else if (isNode(node, 'Assignment')) {
+        if (!String(node.operator || '').includes('='))
+            return false;
+        left = node.leftHandSide;
+    }
+    else {
+        return false;
+    }
+    return expressionTargetsOwnerStorage(left, ownerNames);
+}
+function isOwnerArrayPush(node, ownerNames) {
+    if (!isNode(node, 'FunctionCall'))
+        return false;
+    const callee = node.expression;
+    if (!isNode(callee, 'MemberAccess'))
+        return false;
+    if (String(callee.memberName || '') !== 'push')
+        return false;
+    return expressionTargetsOwnerStorage(callee.expression, ownerNames);
+}
+function expressionTargetsOwnerStorage(expr, ownerNames) {
+    if (!expr || typeof expr !== 'object')
+        return false;
+    if (isNode(expr, 'Identifier'))
+        return ownerNames.has(String(expr.name || ''));
+    if (isNode(expr, 'IndexAccess')) {
+        return expressionTargetsOwnerStorage(expr.base || expr.baseExpression, ownerNames);
+    }
+    if (isNode(expr, 'MemberAccess')) {
+        if (ownerNames.has(String(expr.memberName || '')))
+            return true;
+        return expressionTargetsOwnerStorage(expr.expression, ownerNames);
+    }
+    if (isNode(expr, 'TupleExpression')) {
+        return (expr.components || []).some((component) => expressionTargetsOwnerStorage(component, ownerNames));
+    }
+    return false;
+}
+function collectSameContractCalls(body) {
+    const calls = new Set();
+    walkAny(body, node => {
+        if (!isNode(node, 'FunctionCall'))
+            return false;
+        const name = getCallName(node.expression);
+        if (name)
+            calls.add(name);
+        return false;
+    });
+    return calls;
+}
+function getCallName(expr) {
+    if (!expr || typeof expr !== 'object')
+        return '';
+    if (isNode(expr, 'Identifier'))
+        return String(expr.name || '');
+    if (isNode(expr, 'MemberAccess')) {
+        if (isNode(expr.expression, 'Identifier') && String(expr.expression.name || '') === 'this') {
+            return String(expr.memberName || '');
+        }
+    }
+    return '';
+}
+function containsCallerAuthorizationGuard(body) {
+    for (const stmt of getBlockStatements(body)) {
+        if (isRequireOrAssertWith(stmt, conditionGuardsCaller))
+            return true;
+        if (isNode(stmt, 'IfStatement') && conditionDeniesCaller(stmt.condition) && bodyUnconditionallyExits(stmt.trueBody))
+            return true;
+    }
+    return false;
+}
+function isRequireOrAssertWith(stmt, predicate) {
+    if (!isNode(stmt, 'ExpressionStatement'))
+        return false;
+    const expr = stmt.expression;
+    if (!isRequireOrAssertCall(expr))
+        return false;
+    return predicate(expr.arguments?.[0]);
+}
+function isRequireOrAssertCall(expr) {
+    if (!isNode(expr, 'FunctionCall'))
+        return false;
+    const name = getCallName(expr.expression).toLowerCase();
+    return name === 'require' || name === 'assert';
+}
+function conditionGuardsCaller(node) {
+    if (!node || typeof node !== 'object')
+        return false;
+    if (isCallerEqualityCheck(node))
+        return true;
+    if (isOwnerMembershipCheck(node))
+        return true;
+    for (const child of childrenOf(node)) {
+        if (conditionGuardsCaller(child))
+            return true;
+    }
+    return false;
+}
+function hasEffectiveOneTimeGuard(fn, body) {
+    if (hasOneTimeGuardModifier(fn))
+        return true;
+    const checked = new Set();
+    const written = new Set();
+    walkAny(body, node => {
+        collectInitializedChecks(node, checked);
+        collectInitializedWrites(node, written);
+        return false;
+    });
+    for (const name of checked) {
+        if (written.has(name))
+            return true;
+    }
+    return false;
+}
+function hasOneTimeGuardModifier(fn) {
+    for (const modifier of fn.modifiers || []) {
+        const name = getModifierName(modifier).toLowerCase();
+        if (ONE_TIME_GUARD_MODIFIERS.has(name))
+            return true;
+    }
+    return false;
+}
+function hasCallerAccessControl(fn, body) {
+    for (const modifier of fn.modifiers || []) {
+        const name = getModifierName(modifier).toLowerCase();
+        if (ACCESS_CONTROL_MODIFIERS.has(name))
+            return true;
+    }
+    return !!body && containsCallerAuthorizationGuard(body);
+}
+function collectInitializedChecks(node, out) {
+    if (!isRequireOrAssertCall(node))
+        return;
+    collectInitializedFalseChecks(node.arguments?.[0], out);
+}
+function collectInitializedFalseChecks(node, out) {
+    if (!node || typeof node !== 'object')
+        return;
+    if (isNode(node, 'UnaryOperation') && String(node.operator || '') === '!') {
+        const name = initializedIdentifierName(node.subExpression);
+        if (name)
+            out.add(name);
+    }
+    if (isNode(node, 'BinaryOperation')) {
+        const op = String(node.operator || '');
+        const left = node.left || node.leftExpression;
+        const right = node.right || node.rightExpression;
+        if ((op === '==' || op === '===') && isBooleanLiteral(right, false)) {
+            const name = initializedIdentifierName(left);
+            if (name)
+                out.add(name);
+        }
+        if ((op === '==' || op === '===') && isBooleanLiteral(left, false)) {
+            const name = initializedIdentifierName(right);
+            if (name)
+                out.add(name);
+        }
+    }
+    if (isNode(node, 'BinaryOperation') && String(node.operator || '') === '&&') {
+        collectInitializedFalseChecks(node.left || node.leftExpression, out);
+        collectInitializedFalseChecks(node.right || node.rightExpression, out);
+    }
+}
+function collectInitializedWrites(node, out) {
+    let left = null;
+    let right = null;
+    if (isNode(node, 'BinaryOperation') && String(node.operator || '') === '=') {
+        left = node.left || node.leftExpression;
+        right = node.right || node.rightExpression;
+    }
+    else if (isNode(node, 'Assignment') && String(node.operator || '') === '=') {
+        left = node.leftHandSide;
+        right = node.rightHandSide;
+    }
+    if (!isBooleanLiteral(right, true))
+        return;
+    const name = initializedIdentifierName(left);
+    if (name)
+        out.add(name);
+}
+function initializedIdentifierName(node) {
+    if (isNode(node, 'Identifier') && /initialized/i.test(String(node.name || '')))
+        return String(node.name);
+    if (isNode(node, 'MemberAccess') && /initialized/i.test(String(node.memberName || '')))
+        return String(node.memberName);
+    return '';
+}
+function isBooleanLiteral(node, value) {
+    if (!node || typeof node !== 'object')
+        return false;
+    if (isNode(node, 'BooleanLiteral'))
+        return node.value === value || String(node.value) === String(value);
+    if (isNode(node, 'Literal') && String(node.kind || '').toLowerCase() === 'bool')
+        return node.value === value || String(node.value) === String(value);
+    return false;
+}
+function conditionDeniesCaller(node) {
+    if (!node || typeof node !== 'object')
+        return false;
+    if (isNode(node, 'UnaryOperation') && String(node.operator || '') === '!') {
+        return conditionGuardsCaller(node.subExpression);
+    }
+    if (isNode(node, 'BinaryOperation')) {
+        const op = String(node.operator || '');
+        const left = node.left || node.leftExpression;
+        const right = node.right || node.rightExpression;
+        if ((op === '!=' || op === '!==') && ((isMsgSender(left) && isAuthSubject(right)) || (isMsgSender(right) && isAuthSubject(left))))
+            return true;
+    }
+    return false;
+}
+function isCallerEqualityCheck(node) {
+    if (!isNode(node, 'BinaryOperation'))
+        return false;
+    const op = String(node.operator || '');
+    if (op !== '==' && op !== '===')
+        return false;
+    const left = node.left || node.leftExpression;
+    const right = node.right || node.rightExpression;
+    return (isMsgSender(left) && isAuthSubject(right)) || (isMsgSender(right) && isAuthSubject(left));
+}
+function isOwnerMembershipCheck(node) {
+    if (isNode(node, 'IndexAccess')) {
+        const base = node.base || node.baseExpression;
+        const index = node.index || node.indexExpression;
+        return isOwnerLikeIdentifier(base) && isMsgSender(index);
+    }
+    return false;
+}
+function isOwnerLikeIdentifier(node) {
+    return isNode(node, 'Identifier') && /^(isOwner|owners)$/i.test(String(node.name || ''));
+}
+function isAuthSubject(node) {
+    if (!node || typeof node !== 'object')
+        return false;
+    if (isNode(node, 'Identifier'))
+        return /^(owner|admin|governance|governor|guardian|authority|operator|manager)$/i.test(String(node.name || ''));
+    if (isNode(node, 'MemberAccess'))
+        return /^(owner|admin|governance|governor|guardian|authority|operator|manager)$/i.test(String(node.memberName || ''));
+    return false;
+}
+function isMsgSender(node) {
+    return isNode(node, 'MemberAccess') &&
+        String(node.memberName || '') === 'sender' &&
+        isNode(node.expression, 'Identifier') &&
+        String(node.expression.name || '') === 'msg';
+}
+function bodyUnconditionallyExits(body) {
+    if (!body || typeof body !== 'object')
+        return false;
+    if (isNode(body, 'Block'))
+        return getBlockStatements(body).some(statementGuaranteesExit);
+    return statementGuaranteesExit(body);
+}
+function statementGuaranteesExit(stmt) {
+    if (!stmt || typeof stmt !== 'object')
+        return false;
+    if (isNode(stmt, 'ThrowStatement') || isNode(stmt, 'RevertStatement'))
+        return true;
+    if (isNode(stmt, 'ExpressionStatement') && isNode(stmt.expression, 'FunctionCall')) {
+        return getCallName(stmt.expression.expression).toLowerCase() === 'revert';
+    }
+    if (isNode(stmt, 'Block'))
+        return bodyUnconditionallyExits(stmt);
+    return false;
+}
+function isInterfaceLike(contractNode) {
+    const kind = String(contractNode?.kind || contractNode?.contractKind || '').toLowerCase();
+    return kind === 'interface' || kind === 'library';
+}
+function isConstructor(fn) {
+    if (!fn)
+        return false;
+    if (fn.isConstructor === true)
+        return true;
+    return String(fn.kind || '').toLowerCase() === 'constructor';
+}
+function isExternallyCallable(fn) {
+    if (!fn || isConstructor(fn))
+        return false;
+    const kind = String(fn.kind || '').toLowerCase();
+    if (kind === 'fallback' || kind === 'receive' || fn.isFallback === true || fn.isReceiveEther === true)
+        return false;
+    const visibility = String(fn.visibility || '').toLowerCase();
+    return visibility === 'public' || visibility === 'external';
+}
+function isExternallyReachableCaller(fn) {
+    if (!fn || isConstructor(fn))
+        return false;
+    const kind = String(fn.kind || '').toLowerCase();
+    if (kind === 'fallback' || kind === 'receive' || fn.isFallback === true || fn.isReceiveEther === true)
+        return true;
+    const visibility = String(fn.visibility || '').toLowerCase();
+    return visibility === 'public' || visibility === 'external';
+}
+function expressionToString(expr) {
+    if (!expr || typeof expr !== 'object')
+        return '<unknown>';
+    if (isNode(expr, 'Identifier'))
+        return String(expr.name || '<unknown>');
+    if (isNode(expr, 'MemberAccess'))
+        return `${expressionToString(expr.expression)}.${String(expr.memberName || '')}`;
+    if (isNode(expr, 'FunctionCall')) {
+        return `${expressionToString(expr.expression)}(${(expr.arguments || []).map(expressionToString).join(', ')})`;
+    }
+    if (isNode(expr, 'ElementaryTypeNameExpression'))
+        return String(expr.typeName?.name || expr.typeName || '<type>');
+    if (isNode(expr, 'ElementaryTypeName'))
+        return String(expr.name || '<type>');
+    if (isNode(expr, 'Literal') || isNode(expr, 'StringLiteral'))
+        return JSON.stringify(expr.value ?? '');
+    return '<unknown>';
+}
+function delegateTargetType(expr, contract) {
+    if (!expr || typeof expr !== 'object')
+        return undefined;
+    if (isNode(expr, 'FunctionCall') && expressionToString(expr.expression) === 'address') {
+        return delegateTargetType((expr.arguments || [])[0], contract);
+    }
+    if (isNode(expr, 'Identifier')) {
+        return contract.stateTypes.get(String(expr.name || ''));
+    }
+    return undefined;
+}
+function selectorFromDelegatecallArgs(args) {
+    const first = args[0];
+    if (!isNode(first, 'FunctionCall'))
+        return undefined;
+    const callee = expressionToString(first.expression);
+    if (!callee.endsWith('abi.encodeWithSignature'))
+        return undefined;
+    const signature = stringLiteralValue(first.arguments?.[0]);
+    if (!signature)
+        return undefined;
+    return signature.split('(')[0];
+}
+function stringLiteralValue(node) {
+    if (!node || typeof node !== 'object')
+        return '';
+    if (isNode(node, 'StringLiteral') || isNode(node, 'Literal')) {
+        return typeof node.value === 'string' ? node.value : '';
+    }
+    return '';
+}
+function getModifierName(modifier) {
+    if (!modifier)
+        return '';
+    if (typeof modifier === 'string')
+        return modifier;
+    if (typeof modifier.name === 'string')
+        return modifier.name;
+    if (modifier.name && typeof modifier.name === 'object') {
+        if (typeof modifier.name.name === 'string')
+            return modifier.name.name;
+        if (typeof modifier.name.namePath === 'string')
+            return modifier.name.namePath;
+    }
+    if (modifier.modifierName) {
+        const inner = modifier.modifierName;
+        if (typeof inner === 'string')
+            return inner;
+        if (inner && typeof inner.name === 'string')
+            return inner.name;
+    }
+    return '';
+}
+function functionDisplayName(fn) {
+    if (fn.isFallback === true)
+        return '<fallback>';
+    if (fn.isReceiveEther === true)
+        return '<receive>';
+    const kind = String(fn.kind || '').toLowerCase();
+    if (kind === 'fallback')
+        return '<fallback>';
+    if (kind === 'receive')
+        return '<receive>';
+    const name = fn.name;
+    if (typeof name === 'string' && name.length > 0)
+        return name;
+    return '<anonymous>';
+}
+function getName(node) {
+    return typeof node?.name === 'string' ? node.name : '';
+}
+function getFunctionBody(node) {
+    return node?.body || null;
+}
+function getContractFunctions(contractNode) {
+    return getContractMembers(contractNode).filter(child => isNode(child, 'FunctionDefinition'));
+}
+function getContractMembers(contractNode) {
+    if (!contractNode || typeof contractNode !== 'object')
+        return [];
+    if (Array.isArray(contractNode.subNodes))
+        return contractNode.subNodes;
+    if (Array.isArray(contractNode.nodes))
+        return contractNode.nodes;
+    return [];
+}
+function getBlockStatements(body) {
+    if (!body || typeof body !== 'object')
+        return [];
+    return Array.isArray(body.statements) ? body.statements : [];
+}
+function collectContracts(ast) {
+    const out = [];
+    walkContracts(ast, node => out.push(node));
+    return out;
+}
+function walkContracts(node, visit) {
+    if (!node || typeof node !== 'object')
+        return;
+    if (isNode(node, 'ContractDefinition')) {
+        visit(node);
+        return;
+    }
+    for (const child of childrenOf(node))
+        walkContracts(child, visit);
+}
+function isNode(node, kind) {
+    return node?.type === kind || node?.nodeType === kind;
+}
+function walkAny(node, predicate) {
+    if (!node || typeof node !== 'object')
+        return false;
+    if (predicate(node))
+        return true;
+    for (const child of childrenOf(node)) {
+        if (walkAny(child, predicate))
+            return true;
+    }
+    return false;
+}
+function childrenOf(node) {
+    if (!node || typeof node !== 'object')
+        return [];
+    const children = [];
+    for (const [key, value] of Object.entries(node)) {
+        if (key === 'loc' || key === 'src' || key === 'range' || key === 'typeDescriptions' || key === 'id' || key === 'typeName')
+            continue;
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (item && typeof item === 'object')
+                    children.push(item);
+            }
+        }
+        else if (value && typeof value === 'object') {
+            children.push(value);
+        }
+    }
+    return children;
+}
+function buildLineOffsets(sourceText) {
+    if (sourceText === undefined)
+        return undefined;
+    const lineOffsets = [0];
+    let byteOffset = 0;
+    for (const char of sourceText) {
+        byteOffset += Buffer.byteLength(char, 'utf8');
+        if (char === '\n')
+            lineOffsets.push(byteOffset);
+    }
+    return lineOffsets;
+}
+function getLoc(node, lineOffsets) {
+    if (node?.loc?.start)
+        return node.loc.start;
+    if (!node?.src || !lineOffsets)
+        return undefined;
+    const offset = Number(String(node.src).split(':')[0]);
+    if (!Number.isFinite(offset) || offset < 0)
+        return undefined;
+    let lineIndex = 0;
+    for (let i = 0; i < lineOffsets.length; i++) {
+        if (lineOffsets[i] <= offset)
+            lineIndex = i;
+        else
+            break;
+    }
+    return { line: lineIndex + 1, column: offset - lineOffsets[lineIndex] };
+}
+//# sourceMappingURL=delegatecall-init.js.map