@snovon/solast 0.2.0

package/dist/detectors/unprotected-admin-or-fund-sink.js

@@ -0,0 +1,643 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnprotectedAdminOrFundSinkDetector = void 0;
+const ast_1 = require("./_common/ast");
+const RULE_ID = 'unprotected-admin-or-fund-sink';
+const PROVENANCE = 'x-20231112-mev-0xa247-incorrect-access-control';
+const ACCESS_CONTROL_MODIFIERS = new Set([
+    'onlyowner',
+    'onlyowners',
+    'onlyrole',
+    'onlyadmin',
+    'onlyauthorized',
+    'onlyoperator',
+    'onlyoperators',
+    'onlygovernance',
+    'onlygovernor',
+    'onlyguardian',
+    'onlymanager',
+]);
+class UnprotectedAdminOrFundSinkDetector {
+    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);
+        for (const contract of collectContracts(ast)) {
+            if (isInterfaceLike(contract))
+                continue;
+            const contractName = getName(contract) || '<anonymous>';
+            const functions = new Map();
+            for (const fn of getContractFunctions(contract)) {
+                const body = getFunctionBody(fn);
+                const params = collectParameterInfo(fn);
+                const orderedParameterNames = params.map(p => p.name);
+                const addressLikeParameterNames = new Set(params.filter(p => p.isAddressLike && p.name).map(p => p.name));
+                const info = {
+                    node: fn,
+                    name: functionDisplayName(fn),
+                    body,
+                    orderedParameterNames,
+                    addressLikeParameterNames,
+                    sinkNodes: [],
+                    internalCallSites: collectInternalCallSites(body),
+                };
+                info.sinkNodes = collectSinkNodes(body, addressLikeParameterNames);
+                functions.set(info.name, info);
+            }
+            const seen = new Set();
+            const pending = [];
+            for (const info of functions.values()) {
+                if (!isExternallyCallable(info.node))
+                    continue;
+                if (!info.body)
+                    continue;
+                if (hasRecognizedAccessControlModifier(info.node))
+                    continue;
+                const firstSink = findFirstReachableSink(info, functions, new Map(), new Set());
+                if (!firstSink)
+                    continue;
+                if (hasInlineGuardBeforeNode(info.body, firstSink, functions))
+                    continue;
+                if (hasNonReentrantModifier(info.node) && !hasReachableAdminMutationSink(info, functions, new Set()))
+                    continue;
+                const key = `${contractName}:${info.name}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                const fnLoc = (0, ast_1.getLoc)(info.node, lineOffsets) || { line: 0, column: 0 };
+                pending.push({
+                    isAdminMutation: hasReachableAdminMutationSink(info, functions, new Set()),
+                    finding: {
+                        file,
+                        contract: contractName,
+                        'function': info.name,
+                        line: fnLoc.line,
+                        endLine: fnLoc.line,
+                        column: fnLoc.column,
+                        pattern: RULE_ID,
+                        confidence: 'high',
+                        ruleId: RULE_ID,
+                        severity: 'error',
+                        message: `Incorrect access control in '${contractName}.${info.name}': an externally callable function reaches an admin mutation or contract-held withdrawal without an owner/role guard before the privileged operation.`,
+                        rationale: 'Mirrors a known MEV-bot access-control exploit shape: any caller can invoke an exposed selector that removes caller-supplied admin accounts or withdraws contract-held native/ERC20 value to msg.sender because no owner/role authorization dominates the sink.',
+                        suggestedFix: 'Add onlyOwner/onlyRole or an early require(msg.sender == owner) / require(hasRole(role, msg.sender)) guard before admin mutations and contract-held withdrawals; for user withdrawals, keep per-user accounting effects before interactions and use a nonReentrant guard.',
+                        contractName,
+                        functionName: info.name,
+                        sourceLocation: { line: fnLoc.line, column: fnLoc.column },
+                        findingId: '',
+                        contractHash: '',
+                        provenance: PROVENANCE,
+                        source: PROVENANCE,
+                    },
+                });
+            }
+            const adminFindings = pending.filter(item => item.isAdminMutation);
+            findings.push(...(adminFindings.length > 0 ? adminFindings : pending).map(item => item.finding));
+        }
+        return findings;
+    }
+}
+exports.UnprotectedAdminOrFundSinkDetector = UnprotectedAdminOrFundSinkDetector;
+function collectSinkNodes(body, addressLikeParameterNames) {
+    if (!body)
+        return [];
+    const sinks = [];
+    walk(body, node => {
+        if (isAdminMutationSink(node, addressLikeParameterNames)) {
+            sinks.push(node);
+            return;
+        }
+        if (isTokenTransferToMsgSender(node) || isNativeTransferToMsgSender(node)) {
+            // CEI-aware suppression: a transfer to msg.sender preceded by both a caller-entitlement
+            // guard (e.g. require(balances[msg.sender] >= amount)) and a caller-specific accounting
+            // update (e.g. balances[msg.sender] -= amount, _burn(msg.sender, ...)) is a normal user
+            // withdraw / ERC4626 redeem shape — not the unprotected-admin-or-fund-sink contract-held sweep pattern.
+            if (isCallerAccountedTransferSink(body, node))
+                return;
+            sinks.push(node);
+        }
+    });
+    return sinks;
+}
+function findFirstReachableSink(info, functions, binding, visited) {
+    if (visited.has(info.name))
+        return null;
+    visited.add(info.name);
+    const statements = getBlockStatements(info.body);
+    for (const stmt of statements) {
+        for (const sink of info.sinkNodes) {
+            if (statementContainsNode(stmt, sink))
+                return sink;
+        }
+        for (const cs of collectInternalCallSites(stmt)) {
+            const callee = functions.get(cs.name);
+            if (!callee)
+                continue;
+            const calleeBinding = buildArgumentBinding(callee.orderedParameterNames, cs.arguments, binding);
+            const sink = findFirstReachableSink(callee, functions, calleeBinding, new Set(visited));
+            if (sink)
+                return stmt;
+        }
+    }
+    return null;
+}
+function hasInlineGuardBeforeNode(body, sinkNode, functions) {
+    const statements = getBlockStatements(body);
+    for (const stmt of statements) {
+        if (statementHasInlineGuard(stmt))
+            return true;
+        if (statementContainsNode(stmt, sinkNode))
+            return false;
+        for (const cs of collectInternalCallSites(stmt)) {
+            const callee = functions.get(cs.name);
+            if (callee && hasReachableSink(callee, functions, new Set()))
+                return false;
+        }
+    }
+    return false;
+}
+function hasReachableSink(info, functions, visited) {
+    if (visited.has(info.name))
+        return false;
+    visited.add(info.name);
+    if (info.sinkNodes.length > 0)
+        return true;
+    for (const cs of info.internalCallSites) {
+        const callee = functions.get(cs.name);
+        if (callee && hasReachableSink(callee, functions, visited))
+            return true;
+    }
+    return false;
+}
+function hasReachableAdminMutationSink(info, functions, visited) {
+    if (visited.has(info.name))
+        return false;
+    visited.add(info.name);
+    if (hasAdminMutationSink(info.sinkNodes))
+        return true;
+    for (const cs of info.internalCallSites) {
+        const callee = functions.get(cs.name);
+        if (callee && hasReachableAdminMutationSink(callee, functions, visited))
+            return true;
+    }
+    return false;
+}
+function isAdminMutationSink(node, addressLikeParameterNames) {
+    if (!isAssignmentNode(node))
+        return false;
+    const left = getAssignmentLeft(node);
+    if (!isNode(left, 'IndexAccess'))
+        return false;
+    if (!isAdminLikeReference(getIndexBase(left)))
+        return false;
+    if (!isCallerControlledIndex(getIndexIndex(left), addressLikeParameterNames))
+        return false;
+    return isFalseLike(getAssignmentRight(node));
+}
+function isTokenTransferToMsgSender(node) {
+    if (!isFunctionCall(node))
+        return false;
+    if (getCalleeMemberName(node).toLowerCase() !== 'transfer')
+        return false;
+    const args = getCallArguments(node);
+    return args.length === 2 && isMsgSenderRef(args[0]);
+}
+function isNativeTransferToMsgSender(node) {
+    if (!isFunctionCall(node))
+        return false;
+    if (getCalleeMemberName(node).toLowerCase() !== 'transfer')
+        return false;
+    const args = getCallArguments(node);
+    if (args.length !== 1)
+        return false;
+    const callee = node.expression;
+    return isPayableMsgSender(callee?.expression);
+}
+const CALLER_ACCOUNTING_HELPER_NAMES = new Set([
+    '_burn',
+    'burn',
+    'burnfrom',
+    '_burnfrom',
+    'burnshares',
+    '_burnshares',
+    '_decreasebalance',
+    'decreasebalance',
+    '_subtractbalance',
+]);
+function isCallerAccountedTransferSink(body, sinkNode) {
+    if (!body || !sinkNode)
+        return false;
+    let reached = false;
+    let hasGuard = false;
+    let hasUpdate = false;
+    const visit = (node) => {
+        if (reached || !node || typeof node !== 'object')
+            return;
+        if (node === sinkNode) {
+            reached = true;
+            return;
+        }
+        if (isCallerEntitlementGuardNode(node))
+            hasGuard = true;
+        if (isCallerAccountingUpdateNode(node))
+            hasUpdate = true;
+        for (const child of childrenOf(node)) {
+            if (reached)
+                return;
+            visit(child);
+        }
+    };
+    visit(body);
+    return reached && hasGuard && hasUpdate;
+}
+function isCallerEntitlementGuardNode(node) {
+    if (!isFunctionCall(node))
+        return false;
+    const callee = getCalleeIdentifierName(node).toLowerCase();
+    if (callee !== 'require' && callee !== 'assert')
+        return false;
+    const condition = getCallArguments(node)[0];
+    return !!condition && referencesCallerOwnedMapping(condition);
+}
+function isCallerAccountingUpdateNode(node) {
+    if (isAnyAssignmentNode(node)) {
+        const left = getAssignmentLeft(node);
+        if (left && isNode(left, 'IndexAccess') && isMsgSenderRef(getIndexIndex(left)))
+            return true;
+    }
+    if (isNode(node, 'UnaryOperation')) {
+        const op = String(node.operator || '');
+        if (op === '++' || op === '--') {
+            const sub = node.subExpression || node.expression;
+            if (sub && isNode(sub, 'IndexAccess') && isMsgSenderRef(getIndexIndex(sub)))
+                return true;
+        }
+    }
+    if (isFunctionCall(node)) {
+        const calleeName = (getCalleeIdentifierName(node) || getCalleeMemberName(node)).toLowerCase();
+        if (CALLER_ACCOUNTING_HELPER_NAMES.has(calleeName)) {
+            if (getCallArguments(node).some(isMsgSenderRef))
+                return true;
+        }
+    }
+    return false;
+}
+function referencesCallerOwnedMapping(node) {
+    return walkAny(node, n => isNode(n, 'IndexAccess') && isMsgSenderRef(getIndexIndex(n)));
+}
+function isAnyAssignmentNode(node) {
+    if (!node || typeof node !== 'object')
+        return false;
+    if (isNode(node, 'Assignment'))
+        return true;
+    if (isNode(node, 'BinaryOperation')) {
+        const op = String(node.operator || '');
+        return op === '=' || op === '+=' || op === '-=' || op === '*=' || op === '/=' || op === '%='
+            || op === '|=' || op === '&=' || op === '^=' || op === '<<=' || op === '>>=';
+    }
+    return false;
+}
+function isPayableMsgSender(node) {
+    if (!isFunctionCall(node))
+        return false;
+    const callee = node.expression;
+    if (!isPayableTypeExpression(callee))
+        return false;
+    const args = getCallArguments(node);
+    return args.length === 1 && isMsgSenderRef(args[0]);
+}
+function isPayableTypeExpression(node) {
+    if (!node || typeof node !== 'object')
+        return false;
+    if (isNode(node, 'Identifier'))
+        return String(node.name || '').toLowerCase() === 'payable';
+    if (isNode(node, 'ElementaryTypeNameExpression')) {
+        const typeName = node.typeName;
+        const name = String(typeName?.name || node.name || node.typeDescriptions?.typeString || '').toLowerCase();
+        const stateMutability = String(typeName?.stateMutability || node.stateMutability || '').toLowerCase();
+        if (name === 'address' && stateMutability === 'payable')
+            return true;
+        return name === 'payable' || name === 'address payable';
+    }
+    return false;
+}
+function isAdminLikeReference(node) {
+    const name = getReferenceName(node).toLowerCase();
+    return /admin|owner|role|operator|auth|permission/.test(name);
+}
+function isCallerControlledIndex(node, addressLikeParameterNames) {
+    const name = getIdentifierName(node);
+    if (name && addressLikeParameterNames.has(name))
+        return true;
+    if (isNode(node, 'IndexAccess')) {
+        const baseName = getIdentifierName(getIndexBase(node));
+        return !!baseName && addressLikeParameterNames.has(baseName);
+    }
+    return false;
+}
+function hasAdminMutationSink(sinks) {
+    return sinks.some(s => isAssignmentNode(s));
+}
+function statementHasInlineGuard(stmt) {
+    let guarded = false;
+    walk(stmt, node => {
+        if (guarded || !isFunctionCall(node))
+            return;
+        const callee = getCalleeIdentifierName(node).toLowerCase();
+        if (callee !== 'require' && callee !== 'assert')
+            return;
+        const condition = getCallArguments(node)[0];
+        if (condition && (containsMsgSenderEquality(condition) || containsHasRoleSenderCall(condition)))
+            guarded = true;
+    });
+    return guarded;
+}
+function containsMsgSenderEquality(node) {
+    return walkAny(node, n => {
+        if (!isNode(n, 'BinaryOperation') && !isNode(n, 'Assignment'))
+            return false;
+        const op = String(n.operator || '');
+        if (op !== '==' && op !== '===')
+            return false;
+        const left = getBinaryLeft(n);
+        const right = getBinaryRight(n);
+        return (isMsgSenderRef(left) && !isMsgSenderRef(right)) || (isMsgSenderRef(right) && !isMsgSenderRef(left));
+    });
+}
+function containsHasRoleSenderCall(node) {
+    return walkAny(node, n => {
+        if (!isFunctionCall(n))
+            return false;
+        const callee = (getCalleeIdentifierName(n) || getCalleeMemberName(n)).toLowerCase();
+        if (callee !== 'hasrole' && callee !== '_checkrole' && callee !== 'checkrole')
+            return false;
+        return getCallArguments(n).some(isMsgSenderRef);
+    });
+}
+function hasRecognizedAccessControlModifier(fn) {
+    const modifiers = fn?.modifiers || [];
+    return Array.isArray(modifiers) && modifiers.some((m) => ACCESS_CONTROL_MODIFIERS.has(getModifierName(m).toLowerCase()));
+}
+function hasNonReentrantModifier(fn) {
+    const modifiers = fn?.modifiers || [];
+    return Array.isArray(modifiers) && modifiers.some((m) => getModifierName(m).toLowerCase().includes('nonreentrant'));
+}
+function collectInternalCallSites(body) {
+    const out = [];
+    if (!body)
+        return out;
+    walk(body, n => {
+        if (!isFunctionCall(n))
+            return;
+        const callee = n.expression;
+        if (callee && isNode(callee, 'Identifier')) {
+            const name = String(callee.name || '');
+            if (name)
+                out.push({ name, arguments: getCallArguments(n) });
+        }
+    });
+    return out;
+}
+function buildArgumentBinding(paramNames, callArgs, parentBinding) {
+    const binding = new Map();
+    const n = Math.min(paramNames.length, callArgs.length);
+    for (let i = 0; i < n; i++) {
+        const name = paramNames[i];
+        if (!name)
+            continue;
+        const argName = getIdentifierName(callArgs[i]);
+        binding.set(name, argName && parentBinding.has(argName) ? parentBinding.get(argName) : callArgs[i]);
+    }
+    return binding;
+}
+function collectParameterInfo(fn) {
+    return extractParameterList(fn?.parameters).map(p => ({
+        name: typeof p?.name === 'string' ? p.name : '',
+        isAddressLike: isAddressLikeTypeName(p?.typeName),
+    }));
+}
+function extractParameterList(params) {
+    if (!params)
+        return [];
+    if (Array.isArray(params))
+        return params;
+    if (Array.isArray(params.parameters))
+        return params.parameters;
+    return [];
+}
+function isAddressLikeTypeName(typeName) {
+    if (!typeName || typeof typeName !== 'object')
+        return false;
+    if (isNode(typeName, 'ElementaryTypeName'))
+        return String(typeName.name || '') === 'address';
+    if (isNode(typeName, 'ArrayTypeName'))
+        return isAddressLikeTypeName(typeName.baseTypeName || typeName.baseType);
+    return false;
+}
+function isFalseLike(node) {
+    if (!node || typeof node !== 'object')
+        return false;
+    if (isNode(node, 'BooleanLiteral'))
+        return node.value === false || String(node.value) === 'false';
+    if (isNode(node, 'Literal'))
+        return String(node.value || '').toLowerCase() === 'false';
+    return false;
+}
+function getIndexBase(node) {
+    return node?.base ?? node?.baseExpression;
+}
+function getIndexIndex(node) {
+    return node?.index ?? node?.indexExpression;
+}
+function getAssignmentLeft(node) {
+    return node?.left ?? node?.leftHandSide;
+}
+function getAssignmentRight(node) {
+    return node?.right ?? node?.rightHandSide;
+}
+function getBinaryLeft(node) {
+    return node?.left ?? node?.leftExpression;
+}
+function getBinaryRight(node) {
+    return node?.right ?? node?.rightExpression;
+}
+function isAssignmentNode(node) {
+    if (!node || typeof node !== 'object')
+        return false;
+    if (isNode(node, 'Assignment'))
+        return true;
+    return isNode(node, 'BinaryOperation') && String(node.operator || '') === '=';
+}
+function getReferenceName(node) {
+    if (!node || typeof node !== 'object')
+        return '';
+    if (isNode(node, 'Identifier'))
+        return String(node.name || '');
+    if (isNode(node, 'MemberAccess'))
+        return String(node.memberName || node.member || '');
+    if (isNode(node, 'IndexAccess'))
+        return getReferenceName(getIndexBase(node));
+    return '';
+}
+function getIdentifierName(node) {
+    return node && typeof node === 'object' && isNode(node, 'Identifier') ? String(node.name || '') : '';
+}
+function statementContainsNode(stmt, target) {
+    let found = false;
+    walk(stmt, n => { if (n === target)
+        found = true; });
+    return found;
+}
+function isMsgSenderRef(node) {
+    if (!node || typeof node !== 'object' || !isNode(node, 'MemberAccess'))
+        return false;
+    const memberName = String(node.memberName || node.member || '');
+    if (memberName !== 'sender')
+        return false;
+    const base = node.expression;
+    return isNode(base, 'Identifier') && String(base.name || '') === 'msg';
+}
+function getCalleeMemberName(call) {
+    const expr = call?.expression;
+    return expr && isNode(expr, 'MemberAccess') ? String(expr.memberName || expr.member || '') : '';
+}
+function getCalleeIdentifierName(call) {
+    const expr = call?.expression;
+    return expr && isNode(expr, 'Identifier') ? String(expr.name || '') : '';
+}
+function getCallArguments(node) {
+    return Array.isArray(node?.arguments) ? node.arguments : [];
+}
+function isFunctionCall(node) {
+    return isNode(node, 'FunctionCall');
+}
+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 isExternallyCallable(fn) {
+    if (!fn)
+        return false;
+    if (fn.isConstructor === true)
+        return false;
+    const kind = String(fn.kind || fn.functionKind || '').toLowerCase();
+    if (kind === 'constructor' || kind === 'fallback' || kind === 'receive')
+        return false;
+    if (fn.isFallback === true || fn.isReceiveEther === true)
+        return false;
+    const visibility = String(fn.visibility || '').toLowerCase();
+    return visibility === 'public' || visibility === 'external';
+}
+function isInterfaceLike(contract) {
+    const kind = String(contract?.kind || contract?.contractKind || '').toLowerCase();
+    return kind === 'interface' || kind === 'library';
+}
+function getFunctionBody(node) {
+    return node?.body || null;
+}
+function getBlockStatements(body) {
+    return body && typeof body === 'object' && Array.isArray(body.statements) ? body.statements : [];
+}
+function getContractFunctions(contract) {
+    return getContractMembers(contract).filter(child => isNode(child, 'FunctionDefinition'));
+}
+function getContractMembers(contract) {
+    if (!contract || typeof contract !== 'object')
+        return [];
+    if (Array.isArray(contract.subNodes))
+        return contract.subNodes;
+    if (Array.isArray(contract.nodes))
+        return contract.nodes;
+    return [];
+}
+function collectContracts(ast) {
+    const out = [];
+    walkContracts(ast, n => out.push(n));
+    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 walkAny(node, predicate) {
+    if (!node || typeof node !== 'object')
+        return false;
+    if (predicate(node))
+        return true;
+    return childrenOf(node).some(c => walkAny(c, predicate));
+}
+function walk(node, visit) {
+    if (!node || typeof node !== 'object')
+        return;
+    visit(node);
+    for (const child of childrenOf(node))
+        walk(child, visit);
+}
+function childrenOf(node) {
+    if (!node || typeof node !== 'object')
+        return [];
+    const out = [];
+    for (const [key, value] of Object.entries(node)) {
+        if (key === 'loc' || key === 'src' || key === 'range' || key === 'typeDescriptions' || key === 'id')
+            continue;
+        if (Array.isArray(value)) {
+            for (const item of value)
+                if (item && typeof item === 'object')
+                    out.push(item);
+        }
+        else if (value && typeof value === 'object') {
+            out.push(value);
+        }
+    }
+    return out;
+}
+function isNode(node, kind) {
+    return node?.type === kind || node?.nodeType === kind;
+}
+function getName(node) {
+    return typeof node?.name === 'string' ? node.name : '';
+}
+function functionDisplayName(fn) {
+    return getName(fn) || '<anonymous>';
+}
+function buildLineOffsets(sourceText) {
+    if (sourceText === undefined)
+        return undefined;
+    const offsets = [0];
+    let byteOffset = 0;
+    for (const ch of sourceText) {
+        byteOffset += Buffer.byteLength(ch, 'utf8');
+        if (ch === '\n')
+            offsets.push(byteOffset);
+    }
+    return offsets;
+}
+//# sourceMappingURL=unprotected-admin-or-fund-sink.js.map

package/dist/detectors/unprotected-dex-swap.d.ts

@@ -0,0 +1,43 @@
+import type { ScanResult } from '../index';
+export declare class UnprotectedDexSwapDetector {
+    readonly id = "unprotected-dex-swap";
+    readonly patternKey = "unprotected-dex-swap";
+    readonly supportedAstKinds: "parser"[];
+    readonly descriptor: {
+        id: string;
+        shortDescription: string;
+        helpUri: string;
+        defaultSeverity: "medium";
+        help: string;
+    };
+    private currentFile;
+    private currentContract;
+    private currentFunction;
+    private currentFunctionNode;
+    private findings;
+    private emittedKeys;
+    private zeroConstants;
+    setFile(file: string): void;
+    getFindings(): ScanResult[];
+    ContractDefinition(node: any): void;
+    ContractDefinition_post(_node: any): void;
+    ['ContractDefinition:exit'](node: any): void;
+    StateVariableDeclaration(node: any): void;
+    FunctionDefinition(node: any): void;
+    FunctionDefinition_post(_node: any): void;
+    ['FunctionDefinition:exit'](node: any): void;
+    FunctionCall(node: any): void;
+    private inspectRouterCall;
+    private inspectAggregatorSwapCall;
+    private inspectCurveExchangeCall;
+    private inspectV3StructCall;
+    private getStructName;
+    private emitFinding;
+    private unwrapCallOptions;
+    private argumentByNameOrIndex;
+    private namedArguments;
+    private isZeroLiteral;
+    private unsafeDeadlineReason;
+    private isBareBlockTimestamp;
+    private isUintMaxSentinel;
+}