@snovon/solast 0.2.0

package/dist/detectors/cross-function-reentrancy.js

@@ -0,0 +1,648 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrossFunctionReentrancyDetector = void 0;
+const ast_1 = require("./_common/ast");
+const RULE_ID = 'cross-function-reentrancy';
+const PATTERN = `${RULE_ID}/shared-storage-write-after-interaction`;
+const ASSIGN_OPS = new Set([
+    '=', '+=', '-=', '*=', '/=', '%=',
+    '&=', '|=', '^=', '<<=', '>>=', '>>>=',
+]);
+const UNARY_MUTATORS = new Set(['++', '--', 'delete']);
+const LOW_LEVEL_CALL_MEMBERS = new Set(['call', 'delegatecall', 'send', 'transfer']);
+const BUILTIN_BASE_IDENTIFIERS = new Set([
+    'msg', 'block', 'tx', 'abi', 'super', 'address', 'payable',
+    'type', 'bytes', 'string', 'keccak256', 'sha256', 'ripemd160', 'ecrecover',
+    'assert', 'require', 'revert', 'gasleft',
+]);
+class CrossFunctionReentrancyDetector {
+    id = RULE_ID;
+    patternKey = RULE_ID;
+    supportedAstKinds = ['parser'];
+    currentFile = '';
+    typeKinds = {
+        interfaces: new Set(),
+        contracts: new Set(),
+        libraries: new Set(),
+        structs: new Set(),
+        enums: new Set(),
+    };
+    scanAst(ast, file, _sourceText, ctxArg) {
+        this.currentFile = file;
+        const results = [];
+        if (!ast || ast.type !== 'SourceUnit')
+            return results;
+        this.typeKinds = this.collectTypeKinds(ast);
+        const contractsByName = this.collectContractsByName(ast);
+        // SemanticModel adoption (roadmap 3.3 / Slice 3). Used to enrich
+        // the function-summary set with inherited surfaces so cross-function
+        // reentrancy patterns spanning a base + derived contract resolve.
+        // Falls back to per-contract behaviour when undefined.
+        const semantic = ctxArg?.semantic;
+        for (const child of ast.children || []) {
+            if (child?.type !== 'ContractDefinition')
+                continue;
+            if (child.kind === 'interface' || child.kind === 'library')
+                continue;
+            const stateVars = this.collectStateVariables(child, contractsByName);
+            const stateTypes = this.collectStateVarTypes(child, contractsByName);
+            // === SemanticModel adoption (Slice 3) ===
+            //
+            // Two-phase setup so cross-MRO writes are tracked correctly:
+            //   Phase 1 (this block) walks `semantic.inheritedFunctions` to build
+            //     the union state-var vocabulary across derived + every declarer
+            //     contributing an externally-callable surface, AND buffers an
+            //     `inheritedFnDescriptors` list for phase 2.
+            //   Phase 2 (below) calls `summarizeFunctions` with the UNION vocab
+            //     so a derived function that writes inherited storage (e.g.
+            //     `Derived.increment()` writing inherited `total`) produces a
+            //     non-empty `writes` set. Then we append inherited summaries
+            //     (writes computed against each declarer's own vocab — those
+            //     vars live in declarer's storage layout; downstream pairing
+            //     resolves overlap on shared root names).
+            //
+            // Why the reorder vs. the prior single-pass: previously
+            // `summarizeFunctions` ran with derived-only stateVars, so local
+            // derived writes to inherited storage produced empty writes sets
+            // and the cross-function pairing missed the overlap (xf-inherit-wr).
+            let unionStateVars = stateVars;
+            let unionStateTypes = stateTypes;
+            const inheritedFnDescriptors = [];
+            if (semantic) {
+                const myId = `${file}::${child.name || ''}`;
+                const myInfo = semantic.contracts.get(myId);
+                if (myInfo && myInfo.bases.length > 0) {
+                    // Local-function name set for inherited-dedup, derived from the
+                    // AST using the SAME filter `summarizeFunctions` applies. Built
+                    // here (before summaries exist) so we don't double-count an
+                    // overridden function.
+                    const localFnNames = new Set();
+                    for (const sub of (child.subNodes || [])) {
+                        if (sub?.type !== 'FunctionDefinition')
+                            continue;
+                        if (!sub.body)
+                            continue;
+                        if (sub.isConstructor || sub.kind === 'constructor')
+                            continue;
+                        if (sub.name)
+                            localFnNames.add(sub.name);
+                    }
+                    const u = new Set(stateVars);
+                    const uTypes = new Map(stateTypes);
+                    for (const inhFn of semantic.inheritedFunctions(myId)) {
+                        if (inhFn.contractId === myId)
+                            continue;
+                        if (!inhFn.name)
+                            continue;
+                        if (localFnNames.has(inhFn.name))
+                            continue;
+                        const fnNode = inhFn.node;
+                        if (!fnNode)
+                            continue;
+                        if (!fnNode.body)
+                            continue;
+                        if (fnNode.isConstructor || String(fnNode.kind || '').toLowerCase() === 'constructor')
+                            continue;
+                        const declarer = semantic.contracts.get(inhFn.contractId);
+                        if (!declarer || !declarer.node)
+                            continue;
+                        const declarerStateVars = this.collectStateVariables(declarer.node, contractsByName);
+                        const declarerStateTypes = this.collectStateVarTypes(declarer.node, contractsByName);
+                        for (const v of declarerStateVars)
+                            u.add(v);
+                        for (const [k, v] of declarerStateTypes)
+                            if (!uTypes.has(k))
+                                uTypes.set(k, v);
+                        inheritedFnDescriptors.push({
+                            inhFnNode: fnNode,
+                            name: inhFn.name,
+                            declarerName: declarer.name || '<unknown>',
+                            declarerStateVars,
+                            declarerStateTypes,
+                        });
+                    }
+                    unionStateVars = u;
+                    unionStateTypes = uTypes;
+                }
+            }
+            // Phase 2: summarize local functions using the UNION vocab so writes
+            // to inherited storage are tracked, then append inherited summaries.
+            const summaries = this.summarizeFunctions(child, unionStateVars, unionStateTypes);
+            for (const d of inheritedFnDescriptors) {
+                const fnNode = d.inhFnNode;
+                const localVars = this.collectLocals(fnNode);
+                const localTypes = this.collectLocalTypes(fnNode);
+                summaries.push({
+                    name: d.name,
+                    visibility: String(fnNode.visibility || ''),
+                    stateMutability: String(fnNode.stateMutability || '').toLowerCase(),
+                    modifiers: this.modifierNames(fnNode),
+                    writes: this.collectWrites(fnNode.body, d.declarerStateVars, d.declarerStateTypes, localVars, localTypes),
+                    node: fnNode,
+                    inherited: true,
+                    declarer: d.declarerName,
+                });
+            }
+            if (unionStateVars.size === 0)
+                continue;
+            const externallyReachableMutators = summaries.filter((summary) => this.isExternallyReachable(summary) &&
+                !this.isReadOnly(summary) &&
+                summary.writes.size > 0);
+            const anchorLoc = (child?.loc?.start || { line: 1, column: 0 });
+            const childName = child.name || '<anonymous>';
+            for (const summary of externallyReachableMutators) {
+                const interactions = this.collectVulnerableInteractions(summary.node, unionStateVars, unionStateTypes);
+                for (const interaction of interactions) {
+                    const overlappingSiblings = externallyReachableMutators.filter((other) => other !== summary &&
+                        this.intersects(interaction.postWrites, other.writes));
+                    if (overlappingSiblings.length === 0)
+                        continue;
+                    if (this.allOverlappingSiblingsShareGuard(summary, overlappingSiblings))
+                        continue;
+                    if (summary.inherited) {
+                        // Inherited-vulnerable-interaction finding: anchor at the
+                        // current contract's def line so the operator sees the
+                        // surface in the file under scan; add an instance_key
+                        // discriminator so multiple inherited findings on the same
+                        // anchor don't collide in computeFindingId.
+                        const f = this.makeFinding(child, summary.name, anchorLoc);
+                        f.instance_key = `${childName}::${summary.name}`;
+                        const declarerName = summary.declarer || '<unknown>';
+                        f.message =
+                            `Cross-function reentrancy in inherited function '${summary.name}' (from ${declarerName}): ` +
+                                `external interaction is followed in another sibling by a write of shared storage reachable ` +
+                                `through ${childName}; mark both writers with a shared nonReentrant guard or move the ` +
+                                `external call after the state effect.`;
+                        results.push(f);
+                    }
+                    else {
+                        results.push(this.makeFinding(child, summary.name, interaction.loc));
+                    }
+                }
+            }
+        }
+        return results;
+    }
+    collectVulnerableInteractions(fn, stateVars, stateTypes) {
+        const localVars = this.collectLocals(fn);
+        const localTypes = this.collectLocalTypes(fn);
+        const ctx = {
+            stateVars,
+            stateTypes,
+            localVars,
+            localTypes,
+            interactions: [],
+        };
+        this.walkSourceOrder(fn.body, ctx);
+        return ctx.interactions.filter((interaction) => interaction.postWrites.size > 0);
+    }
+    walkSourceOrder(node, ctx) {
+        if (!node || typeof node !== 'object')
+            return;
+        if (node.type === 'EmitStatement')
+            return;
+        if (node.type === 'TryStatement') {
+            if (node.expression)
+                this.walkSourceOrder(node.expression, ctx);
+            if (node.body)
+                this.walkSourceOrder(node.body, ctx);
+            for (const clause of node.catchClauses || [])
+                this.walkSourceOrder(clause, ctx);
+            for (const clause of node.clauses || [])
+                this.walkSourceOrder(clause, ctx);
+            return;
+        }
+        if (node.type === 'VariableDeclarationStatement') {
+            for (const variable of node.variables || []) {
+                if (variable?.name) {
+                    ctx.localVars.add(variable.name);
+                    ctx.localTypes.set(variable.name, variable.typeName);
+                }
+            }
+            if (node.initialValue)
+                this.walkSourceOrder(node.initialValue, ctx);
+            return;
+        }
+        if (node.type === 'FunctionCall') {
+            if (this.isExternalCallExpression(node, ctx.stateVars, ctx.stateTypes, ctx.localVars, ctx.localTypes)) {
+                for (const arg of node.arguments || [])
+                    this.walkSourceOrder(arg, ctx);
+                ctx.interactions.push({ loc: this.locOf(node), node, postWrites: new Set() });
+                return;
+            }
+            for (const child of this.childNodes(node))
+                this.walkSourceOrder(child, ctx);
+            return;
+        }
+        const writtenRoot = this.stateWriteRoot(node, ctx.stateVars, ctx.localVars);
+        if (writtenRoot) {
+            for (const interaction of ctx.interactions)
+                interaction.postWrites.add(writtenRoot);
+            if (node.type === 'BinaryOperation' && node.right)
+                this.walkSourceOrder(node.right, ctx);
+            return;
+        }
+        for (const child of this.childNodes(node))
+            this.walkSourceOrder(child, ctx);
+    }
+    stateWriteRoot(node, stateVars, localVars) {
+        if (!node || typeof node !== 'object')
+            return '';
+        if (node.type === 'BinaryOperation' && ASSIGN_OPS.has(node.operator)) {
+            return this.stateRoot(node.left, stateVars, localVars);
+        }
+        if (node.type === 'UnaryOperation' && UNARY_MUTATORS.has(node.operator)) {
+            return this.stateRoot(node.subExpression, stateVars, localVars);
+        }
+        return '';
+    }
+    stateRoot(expr, stateVars, localVars) {
+        if (!expr || typeof expr !== 'object')
+            return '';
+        if (expr.type === 'Identifier') {
+            const name = String(expr.name || '');
+            if (localVars.has(name))
+                return '';
+            return stateVars.has(name) ? name : '';
+        }
+        if (expr.type === 'IndexAccess')
+            return this.stateRoot(expr.base, stateVars, localVars);
+        if (expr.type === 'MemberAccess')
+            return this.stateRoot(expr.expression, stateVars, localVars);
+        if (expr.type === 'TupleExpression') {
+            for (const component of expr.components || []) {
+                const root = this.stateRoot(component, stateVars, localVars);
+                if (root)
+                    return root;
+            }
+        }
+        return '';
+    }
+    isExternalCallExpression(call, stateVars, stateTypes, localVars, localTypes) {
+        let callee = call?.expression;
+        if (callee?.type === 'NameValueExpression')
+            callee = callee.expression;
+        if (callee?.type !== 'MemberAccess')
+            return false;
+        const member = String(callee.memberName || '').toLowerCase();
+        const baseName = this.simpleIdentifierName(callee.expression);
+        if (baseName === 'this')
+            return false;
+        if (LOW_LEVEL_CALL_MEMBERS.has(member))
+            return true;
+        if (member === 'staticcall')
+            return false;
+        if (baseName) {
+            if (BUILTIN_BASE_IDENTIFIERS.has(baseName))
+                return false;
+            if (stateVars.has(baseName))
+                return this.classifyBaseType(stateTypes.get(baseName)) === 'external';
+            if (localVars.has(baseName))
+                return this.classifyBaseType(localTypes.get(baseName)) === 'external';
+            return false;
+        }
+        const baseExpr = callee.expression;
+        if (baseExpr?.type === 'FunctionCall' && Array.isArray(baseExpr.arguments) && baseExpr.arguments.length === 1) {
+            return this.classifyCastCallee(baseExpr.expression) === 'external';
+        }
+        return false;
+    }
+    summarizeFunctions(contract, stateVars, stateTypes) {
+        const summaries = [];
+        for (const sub of contract.subNodes || []) {
+            if (sub?.type !== 'FunctionDefinition')
+                continue;
+            if (!sub.body)
+                continue;
+            if (sub.isConstructor || sub.kind === 'constructor')
+                continue;
+            const localVars = this.collectLocals(sub);
+            const localTypes = this.collectLocalTypes(sub);
+            summaries.push({
+                name: sub.name || '<anonymous>',
+                visibility: String(sub.visibility || ''),
+                stateMutability: String(sub.stateMutability || '').toLowerCase(),
+                modifiers: this.modifierNames(sub),
+                writes: this.collectWrites(sub.body, stateVars, stateTypes, localVars, localTypes),
+                node: sub,
+            });
+        }
+        return summaries;
+    }
+    collectWrites(node, stateVars, _stateTypes, localVars, _localTypes) {
+        const writes = new Set();
+        const visit = (current) => {
+            if (!current || typeof current !== 'object')
+                return;
+            if (current.type === 'EmitStatement')
+                return;
+            const root = this.stateWriteRoot(current, stateVars, localVars);
+            if (root)
+                writes.add(root);
+            if (current.type === 'VariableDeclarationStatement') {
+                for (const variable of current.variables || []) {
+                    if (variable?.name)
+                        localVars.add(variable.name);
+                }
+            }
+            for (const child of this.childNodes(current))
+                visit(child);
+        };
+        visit(node);
+        return writes;
+    }
+    isExternallyReachable(summary) {
+        const visibility = summary.visibility.toLowerCase();
+        return visibility !== 'private' && visibility !== 'internal';
+    }
+    isReadOnly(summary) {
+        return summary.stateMutability === 'view' || summary.stateMutability === 'pure';
+    }
+    allOverlappingSiblingsShareGuard(writer, siblings) {
+        const writerGuards = writer.modifiers.filter(isReentrancyGuardName);
+        if (writerGuards.length === 0)
+            return false;
+        return siblings.every((sibling) => {
+            const siblingGuards = sibling.modifiers.filter(isReentrancyGuardName);
+            return siblingGuards.some((siblingGuard) => writerGuards.some((writerGuard) => areGuardsCompatible(writerGuard, siblingGuard)));
+        });
+    }
+    modifierNames(fn) {
+        const names = [];
+        for (const modifier of fn.modifiers || []) {
+            const name = modifier?.name;
+            if (typeof name === 'string')
+                names.push(name.toLowerCase());
+            else if (name?.name)
+                names.push(String(name.name).toLowerCase());
+        }
+        return names;
+    }
+    intersects(a, b) {
+        for (const value of a) {
+            if (b.has(value))
+                return true;
+        }
+        return false;
+    }
+    classifyCastCallee(expr) {
+        if (!expr || typeof expr !== 'object')
+            return 'unknown';
+        if (expr.type === 'ElementaryTypeName') {
+            const name = String(expr.name || '').toLowerCase();
+            return name === 'address' ? 'external' : 'safe';
+        }
+        if (expr.type === 'UserDefinedTypeName')
+            return this.classifyBaseType(expr);
+        if (expr.type === 'Identifier') {
+            const name = String(expr.name || '');
+            if (this.typeKinds.interfaces.has(name))
+                return 'external';
+            if (this.typeKinds.contracts.has(name))
+                return 'external';
+            if (this.typeKinds.libraries.has(name))
+                return 'safe';
+            if (this.typeKinds.structs.has(name))
+                return 'safe';
+            if (this.typeKinds.enums.has(name))
+                return 'safe';
+            if (name === 'address' || name === 'payable')
+                return 'external';
+            return 'unknown';
+        }
+        return 'unknown';
+    }
+    classifyBaseType(typeName) {
+        if (!typeName || typeof typeName !== 'object')
+            return 'unknown';
+        if (typeName.type === 'ElementaryTypeName') {
+            const name = String(typeName.name || '').toLowerCase();
+            return name === 'address' ? 'external' : 'safe';
+        }
+        if (typeName.type === 'UserDefinedTypeName') {
+            const namePath = String(typeName.namePath || '');
+            const head = namePath.split('.')[0];
+            if (this.typeKinds.interfaces.has(head))
+                return 'external';
+            if (this.typeKinds.contracts.has(head))
+                return 'external';
+            if (this.typeKinds.libraries.has(head))
+                return 'safe';
+            if (this.typeKinds.structs.has(head))
+                return 'safe';
+            if (this.typeKinds.enums.has(head))
+                return 'safe';
+            return 'external';
+        }
+        return 'safe';
+    }
+    collectStateVariables(contract, contractsByName, visited = new Set()) {
+        const set = new Set();
+        const contractName = String(contract?.name || '');
+        if (contractName) {
+            if (visited.has(contractName))
+                return set;
+            visited.add(contractName);
+        }
+        for (const sub of contract.subNodes || []) {
+            if (sub?.type !== 'StateVariableDeclaration')
+                continue;
+            for (const v of sub.variables || []) {
+                if (v?.name)
+                    set.add(v.name);
+            }
+        }
+        for (const base of contract.baseContracts || []) {
+            const baseContract = contractsByName.get(this.baseContractName(base));
+            if (!baseContract)
+                continue;
+            for (const name of this.collectStateVariables(baseContract, contractsByName, visited))
+                set.add(name);
+        }
+        return set;
+    }
+    collectStateVarTypes(contract, contractsByName, visited = new Set()) {
+        const map = new Map();
+        const contractName = String(contract?.name || '');
+        if (contractName) {
+            if (visited.has(contractName))
+                return map;
+            visited.add(contractName);
+        }
+        for (const sub of contract.subNodes || []) {
+            if (sub?.type !== 'StateVariableDeclaration')
+                continue;
+            for (const v of sub.variables || []) {
+                if (v?.name)
+                    map.set(v.name, v.typeName);
+            }
+        }
+        for (const base of contract.baseContracts || []) {
+            const baseContract = contractsByName.get(this.baseContractName(base));
+            if (!baseContract)
+                continue;
+            for (const [name, type] of this.collectStateVarTypes(baseContract, contractsByName, visited)) {
+                if (!map.has(name))
+                    map.set(name, type);
+            }
+        }
+        return map;
+    }
+    collectContractsByName(ast) {
+        const map = new Map();
+        for (const child of ast.children || []) {
+            if (child?.type === 'ContractDefinition' && child.name)
+                map.set(child.name, child);
+        }
+        return map;
+    }
+    collectLocals(fn) {
+        const set = new Set();
+        for (const p of fn.parameters || [])
+            if (p?.name)
+                set.add(p.name);
+        for (const p of fn.returnParameters || [])
+            if (p?.name)
+                set.add(p.name);
+        this.harvestLocalsRecursive(fn.body, set);
+        return set;
+    }
+    collectLocalTypes(fn) {
+        const map = new Map();
+        for (const p of fn.parameters || [])
+            if (p?.name)
+                map.set(p.name, p.typeName);
+        for (const p of fn.returnParameters || [])
+            if (p?.name)
+                map.set(p.name, p.typeName);
+        this.harvestLocalTypesRecursive(fn.body, map);
+        return map;
+    }
+    harvestLocalsRecursive(node, set) {
+        if (!node || typeof node !== 'object')
+            return;
+        if (node.type === 'VariableDeclarationStatement') {
+            for (const v of node.variables || [])
+                if (v?.name)
+                    set.add(v.name);
+        }
+        for (const child of this.childNodes(node))
+            this.harvestLocalsRecursive(child, set);
+    }
+    harvestLocalTypesRecursive(node, map) {
+        if (!node || typeof node !== 'object')
+            return;
+        if (node.type === 'VariableDeclarationStatement') {
+            for (const v of node.variables || [])
+                if (v?.name)
+                    map.set(v.name, v.typeName);
+        }
+        for (const child of this.childNodes(node))
+            this.harvestLocalTypesRecursive(child, map);
+    }
+    collectTypeKinds(ast) {
+        const interfaces = new Set();
+        const contracts = new Set();
+        const libraries = new Set();
+        const structs = new Set();
+        const enums = new Set();
+        const visit = (children) => {
+            for (const node of children || []) {
+                if (!node || typeof node !== 'object')
+                    continue;
+                if (node.type === 'ContractDefinition' && node.name) {
+                    if (node.kind === 'interface')
+                        interfaces.add(node.name);
+                    else if (node.kind === 'library')
+                        libraries.add(node.name);
+                    else if (node.kind === 'contract')
+                        contracts.add(node.name);
+                    if (Array.isArray(node.subNodes))
+                        visit(node.subNodes);
+                }
+                else if (node.type === 'StructDefinition' && node.name) {
+                    structs.add(node.name);
+                }
+                else if (node.type === 'EnumDefinition' && node.name) {
+                    enums.add(node.name);
+                }
+            }
+        };
+        visit(ast.children);
+        return { interfaces, contracts, libraries, structs, enums };
+    }
+    baseContractName(base) {
+        const namePath = base?.baseName?.namePath;
+        if (namePath)
+            return String(namePath).split('.').pop() || '';
+        const name = base?.baseName?.name;
+        if (name)
+            return String(name).split('.').pop() || '';
+        return '';
+    }
+    simpleIdentifierName(expr) {
+        if (!expr || typeof expr !== 'object')
+            return '';
+        if (expr.type === 'Identifier')
+            return String(expr.name || '');
+        return '';
+    }
+    locOf(node) {
+        const { line, column } = (0, ast_1.assertLoc)(node);
+        return { line, column };
+    }
+    childNodes(node) {
+        const out = [];
+        for (const [key, value] of Object.entries(node)) {
+            if (key === 'loc' || key === 'range' || key === 'typeName')
+                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;
+    }
+    makeFinding(contract, functionName, loc) {
+        const contractName = contract?.name || '';
+        return {
+            file: this.currentFile,
+            contract: contractName,
+            'function': functionName,
+            line: loc.line,
+            column: loc.column,
+            pattern: PATTERN,
+            confidence: 'high',
+            category: 'vulnerability',
+            ruleId: RULE_ID,
+            severity: 'high',
+            message: `Cross-function reentrancy: '${functionName}' performs an external interaction before finalizing shared storage that another external function can mutate during a callback.`,
+            contractName,
+            functionName,
+            sourceLocation: { line: loc.line, column: loc.column },
+            trace: 'external-interaction-before-shared-storage-finalization',
+            findingId: '',
+            contractHash: '',
+        };
+    }
+}
+exports.CrossFunctionReentrancyDetector = CrossFunctionReentrancyDetector;
+function isReentrancyGuardName(name) {
+    const lower = name.toLowerCase();
+    return lower === 'nonreentrant' ||
+        lower === 'nonreentrantview' ||
+        lower.includes('reentrancyguard');
+}
+function areGuardsCompatible(writerGuard, siblingGuard) {
+    if (writerGuard === siblingGuard)
+        return true;
+    if (writerGuard.includes('reentrancyguard') && siblingGuard.includes('reentrancyguard'))
+        return true;
+    const pair = new Set([writerGuard, siblingGuard]);
+    return pair.has('nonreentrant') && pair.has('nonreentrantview');
+}
+//# sourceMappingURL=cross-function-reentrancy.js.map

package/dist/detectors/cross-protocol-contagion.d.ts

@@ -0,0 +1,20 @@
+import type { ScanResult } from '../index';
+export type CrossProtocolRole = 'oracle' | 'lending' | 'dex' | 'vault' | 'bridge' | 'collateral';
+export interface CrossProtocolMapping {
+    address?: string;
+    interface?: string;
+    protocol: string;
+    role: CrossProtocolRole;
+}
+export interface CrossProtocolContagionConfig {
+    protocolMappings?: CrossProtocolMapping[];
+}
+export declare class CrossProtocolContagionDetector {
+    readonly id = "cross-protocol-contagion";
+    readonly patternKey = "cross-protocol-contagion";
+    readonly supportedAstKinds: ("parser" | "solc")[];
+    private readonly addressMappings;
+    constructor(config?: CrossProtocolContagionConfig);
+    scanAst(ast: any, file: string, sourceText?: string): ScanResult[];
+    private analyzeContract;
+}