@snovon/solast 0.2.0

package/dist/detectors/classic-reentrancy.js

@@ -0,0 +1,645 @@
+"use strict";
+/**
+ * Classic intra-function reentrancy detector. Extracted from
+ * `src/index.ts` per roadmap item 1.1 (split god-file into focused
+ * modules). Public API surface is unchanged — `src/index.ts`
+ * re-exports `ReentrancyDetector` so downstream consumers
+ * (`createDefaultDetectorRegistry`, third-party imports) continue to
+ * see it at the same path.
+ *
+ * The detector class flags an external call (call/delegatecall/
+ * staticcall/send/transfer) followed by a state-modifying operation
+ * in the same function — the canonical CEI violation. See
+ * `docs/detectors/check-effects-interactions.md` for the user-facing
+ * description.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReentrancyDetector = void 0;
+const ast_1 = require("./_common/ast");
+/**
+ * Detects classic reentrancy vulnerabilities:
+ * 1. An external call (call/delegatecall/staticcall/send/transfer)
+ * 2. Followed by a state-modifying operation in the same function
+ *
+ * This violates Checks-Effects-Interactions (CEI). To reduce false
+ * positives we only flag when state modification *follows* a detected
+ * external call — not when state is modified before the call (which is
+ * the safe CEI pattern).
+ */
+class ReentrancyDetector {
+    id = 'classic-reentrancy';
+    patternKey = 'classic-reentrancy';
+    supportedAstKinds = ['parser', 'solc'];
+    findings = [];
+    currentFile = '';
+    // Per-function state
+    currentContract = '';
+    currentContractNode = null;
+    currentFunction = '';
+    skipCurrentFunction = false;
+    stateVariablesByContract = new Map();
+    localVariables = new Set();
+    externalCalls = [];
+    // Tracks how many enclosing try/catch bodies the walker is currently inside.
+    // ExpressionStatement suppresses its own finding emission while > 0 because
+    // the TryStatement handler already scans bodies for the first state write
+    // and emits one finding per try site; without this guard a second try in
+    // the same function would see the first try's call expression in
+    // externalCalls and double-report the second try's in-body mutation.
+    inTryBodyDepth = 0;
+    semantic = undefined;
+    setFile(file) {
+        this.currentFile = file;
+        this.findings = [];
+        this.currentContract = '';
+        this.currentContractNode = null;
+        this.currentFunction = '';
+        this.skipCurrentFunction = false;
+        this.stateVariablesByContract.clear();
+        this.localVariables.clear();
+        this.externalCalls = [];
+        this.inTryBodyDepth = 0;
+    }
+    setSemanticModel(model) {
+        // SemanticModel adoption (roadmap 3.3 / Slice 3). The model lets
+        // this detector see inherited CEI-violating functions across files.
+        // When undefined the detector behaves exactly as before — the
+        // inherited-walk in ContractDefinition:exit is skipped.
+        this.semantic = model;
+    }
+    getFindings() {
+        return this.findings;
+    }
+    ContractDefinition(node) {
+        this.currentContract = node.name || '<anonymous>';
+        this.currentContractNode = node;
+        if (!this.stateVariablesByContract.has(this.currentContract)) {
+            this.stateVariablesByContract.set(this.currentContract, new Set());
+        }
+    }
+    ContractDefinition_post(node) {
+        // After visiting locally-declared FunctionDefinitions, also scan the
+        // contract's MRO for inherited externally-callable functions with
+        // the same CEI-violating shape. Findings anchor at the current
+        // contract's def line so the operator can locate the surface in the
+        // file under scan. Pattern matches access-control.ts (Slice 2b).
+        this.walkInheritedFunctions(node);
+        this.currentContract = '';
+        this.currentContractNode = null;
+    }
+    walkInheritedFunctions(contractNode) {
+        if (!this.semantic)
+            return;
+        if (!contractNode)
+            return;
+        const myId = `${this.currentFile}::${this.currentContract}`;
+        const myInfo = this.semantic.contracts.get(myId);
+        if (!myInfo || myInfo.bases.length === 0)
+            return;
+        // Functions declared locally on this contract are handled by the
+        // regular visitor walk; skip them so an override doesn't double-emit.
+        const localFnNames = new Set();
+        const members = Array.isArray(contractNode?.subNodes) ? contractNode.subNodes
+            : Array.isArray(contractNode?.nodes) ? contractNode.nodes
+                : [];
+        for (const m of members) {
+            if (m?.type === 'FunctionDefinition' && typeof m?.name === 'string') {
+                localFnNames.add(m.name);
+            }
+        }
+        const derivedContract = this.currentContract;
+        const anchorLoc = contractNode?.loc?.start;
+        const anchorLine = anchorLoc?.line || 1;
+        const anchorCol = anchorLoc?.column || 0;
+        for (const inheritedFn of this.semantic.inheritedFunctions(myId)) {
+            if (inheritedFn.contractId === myId)
+                continue;
+            if (!inheritedFn.name)
+                continue;
+            if (localFnNames.has(inheritedFn.name))
+                continue;
+            const fnNode = inheritedFn.node;
+            if (!fnNode)
+                continue;
+            if (!this.isExternallyCallableForInherited(fnNode))
+                continue;
+            const body = fnNode.body;
+            if (!body || !Array.isArray(body.statements))
+                continue;
+            const declarer = this.semantic.contracts.get(inheritedFn.contractId);
+            if (!declarer || !declarer.node)
+                continue;
+            const declarerName = declarer.name || '<unknown>';
+            // Populate state vars for the declarer if not already known (the
+            // declarer may not have been walked by the regular visitor when
+            // its source unit isn't part of this scan).
+            if (!this.stateVariablesByContract.has(declarerName)) {
+                const declarerVars = new Set();
+                const declarerMembers = Array.isArray(declarer.node?.subNodes) ? declarer.node.subNodes
+                    : Array.isArray(declarer.node?.nodes) ? declarer.node.nodes
+                        : [];
+                for (const m of declarerMembers) {
+                    if (m?.type === 'StateVariableDeclaration') {
+                        for (const v of m.variables || []) {
+                            if (v?.name)
+                                declarerVars.add(v.name);
+                        }
+                    }
+                }
+                this.stateVariablesByContract.set(declarerName, declarerVars);
+            }
+            // Swap instance state so the existing per-statement handlers
+            // (ExpressionStatement, VariableDeclarationStatement, etc.) treat
+            // the inherited body as if it were the current scope. Restored on
+            // every loop iteration regardless of whether a finding fired.
+            const savedContract = this.currentContract;
+            const savedFunction = this.currentFunction;
+            const savedSkip = this.skipCurrentFunction;
+            const savedLocalVars = this.localVariables;
+            const savedExternalCalls = this.externalCalls;
+            const savedTryDepth = this.inTryBodyDepth;
+            const findingsBefore = this.findings.length;
+            this.currentContract = declarerName;
+            this.currentFunction = inheritedFn.name;
+            this.skipCurrentFunction = this.hasReentrancyGuardModifier(fnNode);
+            this.localVariables = new Set();
+            this.externalCalls = [];
+            this.inTryBodyDepth = 0;
+            for (const p of fnNode.parameters || []) {
+                if (p?.name)
+                    this.localVariables.add(p.name);
+            }
+            for (const p of fnNode.returnParameters || []) {
+                if (p?.name)
+                    this.localVariables.add(p.name);
+            }
+            try {
+                if (!this.skipCurrentFunction) {
+                    this.dispatchStatementForInherited(body);
+                }
+            }
+            finally {
+                this.currentContract = savedContract;
+                this.currentFunction = savedFunction;
+                this.skipCurrentFunction = savedSkip;
+                this.localVariables = savedLocalVars;
+                this.externalCalls = savedExternalCalls;
+                this.inTryBodyDepth = savedTryDepth;
+            }
+            // Patch any findings emitted during the inherited walk to anchor
+            // at the derived contract and carry an instance_key discriminator
+            // (so multiple inherited findings on the same derived contract
+            // don't collide in computeFindingId — same pattern as Slice 2a/2b).
+            for (let i = findingsBefore; i < this.findings.length; i++) {
+                const f = this.findings[i];
+                f.line = anchorLine;
+                f.endLine = anchorLine;
+                f.column = anchorCol;
+                f.contract = derivedContract;
+                f.contractName = derivedContract;
+                f.sourceLocation = { line: anchorLine, column: anchorCol };
+                f.instance_key = `${derivedContract}::${inheritedFn.name}`;
+                f.message =
+                    `Potential reentrancy: inherited function '${inheritedFn.name}' from ${declarerName} ` +
+                        `performs an external call followed by a state modification (CEI violation reachable ` +
+                        `through ${derivedContract}).`;
+            }
+        }
+    }
+    // Visitor-style external-callability check (subset of the helper used
+    // in src/detectors/access-control.ts — kept self-contained here to
+    // avoid cross-detector coupling). Returns true for public/external
+    // visibility; treats fallback/receive as externally callable too.
+    isExternallyCallableForInherited(fnNode) {
+        if (!fnNode)
+            return false;
+        if (fnNode.isConstructor === true)
+            return false;
+        const kind = String(fnNode.kind || '').toLowerCase();
+        if (kind === 'constructor')
+            return false;
+        const visibility = String(fnNode.visibility || '').toLowerCase();
+        if (visibility === 'public' || visibility === 'external')
+            return true;
+        if (kind === 'fallback' || kind === 'receive')
+            return true;
+        if (fnNode.isFallback === true || fnNode.isReceiveEther === true)
+            return true;
+        return false;
+    }
+    // Dispatch a single statement node into the appropriate per-type
+    // handler so the inherited body produces the same per-statement
+    // observations (external-call recording, state-write detection) as
+    // the normal visitor walk would. We only route the statement types
+    // the detector actually observes; everything else is a no-op.
+    dispatchStatementForInherited(stmt) {
+        if (!stmt || typeof stmt !== 'object')
+            return;
+        switch (stmt.type) {
+            case 'Block':
+                for (const child of stmt.statements || [])
+                    this.dispatchStatementForInherited(child);
+                return;
+            case 'VariableDeclarationStatement':
+                this.VariableDeclarationStatement(stmt);
+                return;
+            case 'ExpressionStatement':
+                this.ExpressionStatement(stmt);
+                return;
+            case 'IfStatement':
+                this.dispatchStatementForInherited(stmt.trueBody);
+                this.dispatchStatementForInherited(stmt.falseBody);
+                return;
+            case 'ForStatement':
+            case 'WhileStatement':
+            case 'DoWhileStatement':
+                this.dispatchStatementForInherited(stmt.body);
+                return;
+            case 'UncheckedStatement':
+                this.dispatchStatementForInherited(stmt.body || stmt.block);
+                return;
+            case 'TryStatement':
+                this.TryStatement(stmt);
+                this.dispatchStatementForInherited(stmt.body);
+                for (const c of stmt.catchClauses || []) {
+                    if (c?.body)
+                        this.dispatchStatementForInherited(c.body);
+                }
+                this.TryStatement_post(stmt);
+                return;
+            default:
+                return;
+        }
+    }
+    StateVariableDeclaration(node) {
+        const stateVariables = this.getCurrentStateVariables();
+        for (const variable of node.variables || []) {
+            if (variable.name) {
+                stateVariables.add(variable.name);
+            }
+        }
+    }
+    FunctionDefinition(node) {
+        this.currentFunction = node.name || '<anonymous>';
+        this.skipCurrentFunction = this.hasReentrancyGuardModifier(node);
+        this.localVariables = new Set();
+        this.externalCalls = [];
+        this.inTryBodyDepth = 0;
+        for (const parameter of node.parameters || []) {
+            if (parameter.name) {
+                this.localVariables.add(parameter.name);
+            }
+        }
+        for (const parameter of node.returnParameters || []) {
+            if (parameter.name) {
+                this.localVariables.add(parameter.name);
+            }
+        }
+    }
+    FunctionDefinition_post(_node) {
+        this.currentFunction = '';
+        this.skipCurrentFunction = false;
+        this.localVariables.clear();
+        this.externalCalls = [];
+        this.inTryBodyDepth = 0;
+    }
+    /**
+     * Catch variable declarations where the initializer is an external call.
+     * E.g. (bool success, ) = msg.sender.call{value: amount}("");
+     */
+    VariableDeclarationStatement(node) {
+        for (const variable of node.variables || []) {
+            if (variable?.name) {
+                this.localVariables.add(variable.name);
+            }
+        }
+        if (!this.currentFunction || this.skipCurrentFunction)
+            return;
+        if (!node.initialValue)
+            return;
+        if (this.isExternalCall(node.initialValue)) {
+            this.externalCalls.push(node.initialValue);
+        }
+    }
+    /**
+     * Catch expression statements that are direct external calls.
+     * E.g. msg.sender.call{value: amount}(""); (without tuple assignment)
+     */
+    ExpressionStatement(node) {
+        if (!this.currentFunction || this.skipCurrentFunction)
+            return;
+        if (!node.expression)
+            return;
+        // tryLoc-with-floor: solc-walker may yield loc=0 on inner expressions.
+        const loc = (0, ast_1.tryLoc)(node) ?? { line: 0, endLine: 0, column: 0 };
+        const { line, endLine, column } = loc;
+        const externalCall = this.findExternalCall(node.expression);
+        // Check for state-modifying operations after an external call. Skip when
+        // the walker is currently inside a try/catch body — TryStatement scans
+        // those bodies itself and emits a single finding per try site, so we'd
+        // otherwise double-report (once from TryStatement, once here using a
+        // prior call from the enclosing scope).
+        if (this.inTryBodyDepth === 0 && this.externalCalls.length > 0) {
+            if (this.isStateModification(node.expression)) {
+                const externalCallNode = this.externalCalls[0];
+                this.findings.push({
+                    file: this.currentFile,
+                    contract: this.currentContract,
+                    'function': this.currentFunction,
+                    line: line,
+                    endLine,
+                    column,
+                    pattern: 'classic-reentrancy',
+                    confidence: 'high',
+                    ruleId: 'classic-reentrancy',
+                    severity: 'error',
+                    message: `Potential reentrancy: state modification after external call in function '${this.currentFunction}'`,
+                    contractName: this.currentContract,
+                    functionName: this.currentFunction,
+                    sourceLocation: {
+                        line,
+                        column
+                    },
+                    externalCallNode,
+                    stateMutationNode: node.expression,
+                    findingId: '',
+                    contractHash: ''
+                });
+            }
+        }
+        if (externalCall) {
+            this.externalCalls.push(externalCall);
+        }
+    }
+    /**
+     * Solidity `try X.f(...) { ... } catch { ... }` always wraps an external call
+     * (or contract creation), so the try expression is itself the call site for
+     * classic-reentrancy purposes regardless of whether it parses as a low-level
+     * `.call(...)`. We scan success and catch bodies for the first state write
+     * and emit a single finding per try statement to avoid duplicating findings
+     * across paths that share the same underlying call. The try expression is
+     * also recorded as an external call in `TryStatement_post` so that a state
+     * write in the enclosing function *after* the try/catch is flagged via the
+     * normal post-call traversal — covering the `try f() { } catch { } x -= 1;`
+     * pattern that has empty (or emit-only) bodies but a real post-call write.
+     */
+    TryStatement(node) {
+        if (!this.currentFunction || this.skipCurrentFunction)
+            return;
+        if (!node.expression)
+            return;
+        for (const parameter of node.returnParameters || []) {
+            if (parameter?.name)
+                this.localVariables.add(parameter.name);
+        }
+        for (const clause of node.catchClauses || []) {
+            for (const parameter of clause?.parameters || []) {
+                if (parameter?.name)
+                    this.localVariables.add(parameter.name);
+            }
+        }
+        // Suppress in-body ExpressionStatement emissions while we descend — see
+        // `inTryBodyDepth` field comment for the rationale.
+        this.inTryBodyDepth++;
+        const bodies = [];
+        if (node.body)
+            bodies.push(node.body);
+        for (const clause of node.catchClauses || []) {
+            if (clause?.body)
+                bodies.push(clause.body);
+        }
+        let mutation = null;
+        let mutationStatement = null;
+        for (const body of bodies) {
+            const found = this.findFirstStateMutationStatement(body);
+            if (found) {
+                mutation = found.expression;
+                mutationStatement = found.statement;
+                break;
+            }
+        }
+        if (!mutation || !mutationStatement)
+            return;
+        const callExpr = node.expression;
+        // tryLoc-with-floor + two-arg fallback: mutationStatement primary,
+        // node (the TryStatement) as fallback when the mutation is
+        // synthesised.
+        const loc = (0, ast_1.tryLoc)(mutationStatement, node) ?? { line: 0, endLine: 0, column: 0 };
+        const { line, endLine, column } = loc;
+        this.findings.push({
+            file: this.currentFile,
+            contract: this.currentContract,
+            'function': this.currentFunction,
+            line,
+            endLine,
+            column,
+            pattern: 'classic-reentrancy',
+            confidence: 'high',
+            ruleId: 'classic-reentrancy',
+            severity: 'error',
+            message: `Potential reentrancy: state modification after external call in function '${this.currentFunction}'`,
+            contractName: this.currentContract,
+            functionName: this.currentFunction,
+            sourceLocation: { line, column },
+            externalCallNode: callExpr,
+            stateMutationNode: mutation,
+            findingId: '',
+            contractHash: ''
+        });
+    }
+    TryStatement_post(node) {
+        if (!this.currentFunction || this.skipCurrentFunction)
+            return;
+        if (!node.expression)
+            return;
+        if (this.inTryBodyDepth > 0)
+            this.inTryBodyDepth--;
+        // Record the try expression as an external call so the existing
+        // post-call traversal flags any state write that follows the try/catch
+        // in the enclosing function body.
+        this.externalCalls.push(node.expression);
+    }
+    findFirstStateMutationStatement(stmt) {
+        if (!stmt || typeof stmt !== 'object')
+            return null;
+        switch (stmt.type) {
+            case 'Block':
+                for (const child of stmt.statements || []) {
+                    const found = this.findFirstStateMutationStatement(child);
+                    if (found)
+                        return found;
+                }
+                return null;
+            case 'ExpressionStatement':
+                if (stmt.expression && this.isStateModification(stmt.expression)) {
+                    return { statement: stmt, expression: stmt.expression };
+                }
+                return null;
+            case 'IfStatement': {
+                const t = this.findFirstStateMutationStatement(stmt.trueBody);
+                if (t)
+                    return t;
+                return this.findFirstStateMutationStatement(stmt.falseBody);
+            }
+            case 'ForStatement':
+            case 'WhileStatement':
+            case 'DoWhileStatement':
+                return this.findFirstStateMutationStatement(stmt.body);
+            case 'UncheckedStatement':
+                return this.findFirstStateMutationStatement(stmt.body);
+            case 'TryStatement':
+                return null;
+            default:
+                return null;
+        }
+    }
+    /**
+     * Check if an expression is an external call (call/delegatecall/staticcall/send/transfer)
+     */
+    isExternalCall(expr) {
+        if (!expr)
+            return false;
+        // Walk through FunctionCall -> NameValueExpression -> MemberAccess chain
+        let current = expr;
+        // Unwrap FunctionCall
+        if (current.type === 'FunctionCall') {
+            current = current.expression;
+        }
+        // Unwrap NameValueExpression (msg.sender.call{value: X}(""))
+        if (current?.type === 'NameValueExpression') {
+            current = current.expression;
+        }
+        // Check for MemberAccess with call/delegatecall/staticcall/send/transfer
+        if (current?.type === 'MemberAccess') {
+            const member = current.memberName?.toLowerCase();
+            return member === 'call' || member === 'delegatecall' || member === 'staticcall' || member === 'send' || member === 'transfer';
+        }
+        return false;
+    }
+    findExternalCall(expr) {
+        if (!expr || typeof expr !== 'object')
+            return null;
+        if (this.isExternalCall(expr))
+            return expr;
+        for (const key of [
+            'expression',
+            'left',
+            'right',
+            'subExpression',
+            'base',
+            'index',
+            'initialValue',
+            'arguments',
+            'components'
+        ]) {
+            const value = expr[key];
+            if (Array.isArray(value)) {
+                for (const item of value) {
+                    const found = this.findExternalCall(item);
+                    if (found)
+                        return found;
+                }
+            }
+            else {
+                const found = this.findExternalCall(value);
+                if (found)
+                    return found;
+            }
+        }
+        return null;
+    }
+    /**
+     * Check if an expression modifies contract state.
+     * Heuristic: assignment operators only count when their left side resolves
+     * to a known state variable in the current contract.
+     */
+    isStateModification(expr) {
+        if (!expr)
+            return false;
+        // Binary operations with assignment operators like +=, -=, =, etc.
+        if (expr.type === 'BinaryOperation') {
+            const ops = ['=', '+=', '-=', '*=', '/=', '%=', '&=', '|=', '^=', '<<=', '>>=', '>>>='];
+            if (ops.includes(expr.operator)) {
+                return this.isStateReference(expr.left);
+            }
+        }
+        if (expr.type === 'UnaryOperation') {
+            const ops = ['++', '--'];
+            if (ops.includes(expr.operator)) {
+                return this.isStateReference(expr.subExpression);
+            }
+        }
+        // Function calls that mutate state (e.g., _update, _mint, _transfer)
+        // These are common in ERC20/ERC721 and often state-modifying
+        if (expr.type === 'FunctionCall') {
+            const name = expr.expression?.name || '';
+            if (name === 'selfdestruct' || name === 'suicide') {
+                return true;
+            }
+            if (name.startsWith('_') || name === '_mint' || name === '_burn' || name === '_transfer' || name === '_update') {
+                return true;
+            }
+        }
+        return false;
+    }
+    getCurrentStateVariables() {
+        if (!this.stateVariablesByContract.has(this.currentContract)) {
+            this.stateVariablesByContract.set(this.currentContract, new Set());
+        }
+        return this.stateVariablesByContract.get(this.currentContract);
+    }
+    hasReentrancyGuardModifier(node) {
+        for (const modifier of node.modifiers || []) {
+            const name = this.getNodeName(modifier).toLowerCase();
+            if (name === 'nonreentrant' || name.includes('reentrancyguard')) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getNodeName(node) {
+        if (!node)
+            return '';
+        if (typeof node === 'string')
+            return node;
+        if (node.name)
+            return this.getNodeName(node.name);
+        if (node.type === 'Identifier')
+            return node.name || '';
+        if (node.type === 'ModifierInvocation')
+            return this.getNodeName(node.name);
+        if (node.type === 'MemberAccess')
+            return node.memberName || '';
+        return '';
+    }
+    isStateReference(expr) {
+        if (!expr)
+            return false;
+        if (expr.type === 'Identifier') {
+            const stateVariables = this.getCurrentStateVariables();
+            return stateVariables.has(expr.name) && !this.localVariables.has(expr.name);
+        }
+        if (expr.type === 'IndexAccess') {
+            return this.isStateReference(expr.base);
+        }
+        if (expr.type === 'MemberAccess') {
+            return this.isStateReference(expr.expression);
+        }
+        return false;
+    }
+}
+exports.ReentrancyDetector = ReentrancyDetector;
+// Alias `_post` handlers to `:exit` so that `parser.visit` (which fires
+// `<Type>:exit`) and the solc-walker (which fires `<Type>_post`) both reach
+// the same hook. The detector's `TryStatement_post` registers the try
+// expression as an external call once body traversal has completed; without
+// the parser-side alias, post-try state writes would only be flagged on the
+// solc-AST path.
+const _reentrancyProto = ReentrancyDetector.prototype;
+_reentrancyProto['TryStatement:exit'] = _reentrancyProto.TryStatement_post;
+// Slice 3 (roadmap 3.3): walkInheritedFunctions runs in
+// ContractDefinition_post; parser.visit fires <Type>:exit not <Type>_post,
+// so route both events to the same handler. Same alias pattern as
+// access-control.ts (Slice 2b).
+_reentrancyProto['ContractDefinition:exit'] = _reentrancyProto.ContractDefinition_post;
+//# sourceMappingURL=classic-reentrancy.js.map

package/dist/detectors/coinbase-morpho-wethloan-policy.d.ts

@@ -0,0 +1,29 @@
+import type { ScanResult } from '../index';
+export declare class CoinbaseMorphoWethLoanPolicyDetector {
+    readonly id = "coinbase-morpho-wethloan-policy";
+    readonly patternKey = "coinbase-morpho-wethloan-policy";
+    readonly supportedAstKinds: "parser"[];
+    private currentFile;
+    private contracts;
+    private findings;
+    setFile(file: string): void;
+    getFindings(): ScanResult[];
+    SourceUnit(node: any): void;
+    private analyzeContracts;
+    private findPolicyVariantPairs;
+    private checkDuplicateInstallation;
+    private findInstallFunction;
+    private extractUniquenessGuard;
+    private extractGuardFromNegation;
+    private indexAccessBaseVar;
+    private indexAccessKey;
+    private keySignature;
+    private getCalleeName;
+    private resolveFunctionDefinition;
+    private functionContainsMappedUniquenessPattern;
+    private rejectsWethCollateral;
+    private isWethRejection;
+    private isCollateralTerm;
+    private isWethTerm;
+    private makeFinding;
+}