@snovon/solast 0.2.0

package/dist/detectors/chainlink-deprecated-function.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainlinkDeprecatedFunctionDetector = void 0;
+const RULE_ID = 'chainlink-deprecated-function';
+const CHAINLINK_IMPORT_PATTERN = /chainlink/i;
+const CHAINLINK_FEED_TYPES = new Set([
+    'aggregatorinterface',
+    'aggregatorv2v3interface',
+    'aggregatorv3interface',
+]);
+class ChainlinkDeprecatedFunctionDetector {
+    id = RULE_ID;
+    patternKey = RULE_ID;
+    supportedAstKinds = ['parser'];
+    scanAst(ast, file) {
+        if (!ast || typeof ast !== 'object')
+            return [];
+        const findings = [];
+        const chainlinkTypes = collectChainlinkTypes(ast);
+        const fileHasChainlinkImport = collectImports(ast).some(p => CHAINLINK_IMPORT_PATTERN.test(p));
+        const rootScope = {
+            contractName: '',
+            functionName: '',
+            variables: new Map(),
+        };
+        walk(ast, rootScope, node => {
+            if (!isLatestAnswerCall(node))
+                return;
+            const receiver = getCallReceiver(node);
+            if (!isChainlinkReceiver(receiver, rootScope.variables, chainlinkTypes, fileHasChainlinkImport)) {
+                return;
+            }
+            const loc = getLoc(node) || getLoc(receiver) || { line: 0, column: 0 };
+            findings.push({
+                file,
+                contract: rootScope.contractName,
+                'function': rootScope.functionName,
+                line: loc.line,
+                endLine: loc.line,
+                column: loc.column,
+                pattern: RULE_ID,
+                confidence: 'high',
+                ruleId: RULE_ID,
+                severity: 'medium',
+                message: 'Deprecated Chainlink oracle read: latestAnswer() can return stale or incomplete data; use latestRoundData() and validate the round and timestamp.',
+                rationale: 'Chainlink feed consumers should prefer latestRoundData() so callers can inspect round metadata and reject stale, incomplete, or invalid oracle answers.',
+                suggestedFix: 'Replace latestAnswer() with latestRoundData(), then validate answeredInRound, updatedAt, and answer before using the price.',
+                contractName: rootScope.contractName,
+                functionName: rootScope.functionName,
+                sourceLocation: { line: loc.line, column: loc.column },
+                findingId: '',
+                contractHash: '',
+            });
+        });
+        return findings;
+    }
+}
+exports.ChainlinkDeprecatedFunctionDetector = ChainlinkDeprecatedFunctionDetector;
+function collectChainlinkTypes(ast) {
+    const types = new Set(CHAINLINK_FEED_TYPES);
+    walkPlain(ast, node => {
+        if (!isNode(node, 'ContractDefinition'))
+            return;
+        const kind = String(node.kind || node.contractKind || '').toLowerCase();
+        const name = getName(node);
+        if (kind === 'interface' && CHAINLINK_FEED_TYPES.has(name.toLowerCase())) {
+            types.add(name.toLowerCase());
+        }
+    });
+    return types;
+}
+function isLatestAnswerCall(node) {
+    if (!isNode(node, 'FunctionCall'))
+        return false;
+    const callee = unwrapCallOptions(node.expression);
+    return isNode(callee, 'MemberAccess') && String(callee.memberName || '') === 'latestAnswer';
+}
+function getCallReceiver(call) {
+    const callee = unwrapCallOptions(call?.expression);
+    return isNode(callee, 'MemberAccess') ? callee.expression : null;
+}
+function isChainlinkReceiver(receiver, variables, chainlinkTypes, fileHasChainlinkImport) {
+    if (!isNode(receiver, 'Identifier'))
+        return false;
+    const receiverName = String(receiver.name || '');
+    const typeName = variables.get(receiverName);
+    if (typeName && chainlinkTypes.has(typeName.toLowerCase()))
+        return true;
+    return fileHasChainlinkImport && /^(aggregator|feed|priceFeed)$/i.test(receiverName);
+}
+function collectImports(ast) {
+    const imports = [];
+    walkPlain(ast, node => {
+        if (!isNode(node, 'ImportDirective'))
+            return;
+        for (const candidate of [node.path, node.absolutePath, node.file, node.pathLiteral?.value]) {
+            if (typeof candidate === 'string' && candidate.length > 0) {
+                imports.push(candidate);
+                return;
+            }
+        }
+    });
+    return imports;
+}
+function walk(node, scope, visit) {
+    if (!node || typeof node !== 'object')
+        return;
+    const previousContract = scope.contractName;
+    const previousFunction = scope.functionName;
+    const previousVariables = scope.variables;
+    if (isNode(node, 'ContractDefinition')) {
+        scope.contractName = getName(node) || '<anonymous>';
+        scope.functionName = '';
+        scope.variables = new Map(previousVariables);
+    }
+    if (isNode(node, 'FunctionDefinition') || isNode(node, 'ModifierDefinition')) {
+        scope.functionName = functionDisplayName(node);
+        scope.variables = new Map(previousVariables);
+    }
+    if (isNode(node, 'VariableDeclaration')) {
+        const name = getName(node);
+        const typeName = getTypeName(node.typeName);
+        if (name && typeName)
+            scope.variables.set(name, typeName);
+    }
+    visit(node);
+    for (const child of childrenOf(node))
+        walk(child, scope, visit);
+    if (isNode(node, 'ContractDefinition')) {
+        scope.contractName = previousContract;
+        scope.functionName = previousFunction;
+        scope.variables = previousVariables;
+    }
+    else if (isNode(node, 'FunctionDefinition') || isNode(node, 'ModifierDefinition')) {
+        scope.functionName = previousFunction;
+        scope.variables = previousVariables;
+    }
+}
+function walkPlain(node, visit) {
+    if (!node || typeof node !== 'object')
+        return;
+    visit(node);
+    for (const child of childrenOf(node))
+        walkPlain(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 unwrapCallOptions(expr) {
+    if (!expr || typeof expr !== 'object')
+        return expr;
+    if (isNode(expr, 'NameValueExpression') || isNode(expr, 'FunctionCallOptions'))
+        return expr.expression;
+    return expr;
+}
+function getTypeName(typeName) {
+    if (!typeName || typeof typeName !== 'object')
+        return '';
+    if (typeof typeName.namePath === 'string')
+        return typeName.namePath;
+    if (typeof typeName.name === 'string')
+        return typeName.name;
+    if (typeName.pathNode)
+        return getTypeName(typeName.pathNode);
+    if (Array.isArray(typeName.path))
+        return typeName.path.map((part) => getName(part)).filter(Boolean).join('.');
+    return '';
+}
+function getLoc(node) {
+    if (node?.loc?.start)
+        return { line: node.loc.start.line || 0, column: node.loc.start.column || 0 };
+    return null;
+}
+function getName(node) {
+    return typeof node?.name === 'string' ? node.name : '';
+}
+function functionDisplayName(node) {
+    const kind = String(node?.kind || '').toLowerCase();
+    if (node?.isConstructor === true || kind === 'constructor')
+        return '<constructor>';
+    if (node?.isFallback === true || kind === 'fallback')
+        return '<fallback>';
+    if (node?.isReceiveEther === true || kind === 'receive')
+        return '<receive>';
+    return getName(node) || '<anonymous>';
+}
+function isNode(node, kind) {
+    return node?.type === kind || node?.nodeType === kind;
+}
+//# sourceMappingURL=chainlink-deprecated-function.js.map

package/dist/detectors/chainlink-tx-origin.d.ts

@@ -0,0 +1,7 @@
+import type { ScanResult } from '../index';
+export declare class ChainlinkTxOriginDetector {
+    readonly id = "chainlink-tx-origin";
+    readonly patternKey = "chainlink-tx-origin";
+    readonly supportedAstKinds: ("parser" | "solc")[];
+    scanAst(ast: any, file: string, sourceText?: string): ScanResult[];
+}

package/dist/detectors/chainlink-tx-origin.js

@@ -0,0 +1,363 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainlinkTxOriginDetector = void 0;
+const ast_1 = require("./_common/ast");
+const RULE_ID = 'chainlink-tx-origin';
+const PROVENANCE = 'x-20260503-chainlink-deprecated-function-tx-origin';
+const CHAINLINK_BASE_CONTRACT_NAMES = new Set([
+    'chainlinkclient',
+    'chainlinkrequestable',
+    'chainlinkoracle',
+    'aggregatorinterface',
+    'aggregatorv3interface',
+    'aggregatorv2v3interface',
+    'operatorinterface',
+    'operator',
+    'oracleinterface',
+    'linktokeninterface',
+    'feedregistryinterface',
+    'vrfconsumerbase',
+    'vrfconsumerbasev2',
+    'vrfcoordinatorv2interface',
+]);
+const DEPRECATED_CHAINLINK_FUNCTIONS = new Set([
+    'getaggregator',
+    'getauthorizationstatus',
+    'sendchainlinkrequest',
+    'sendchainlinkrequestto',
+    'chainlinkrequest',
+    'chainlinkrequestto',
+    'fulfilloraclerequest',
+    'fulfilloraclerequest2',
+    'cancelrequest',
+    'cancelchainlinkrequest',
+    'fulfill',
+    'requestdata',
+    'requestethereumprice',
+]);
+const CHAINLINK_IMPORT_PATTERN = /chainlink/i;
+const COMPARISON_OPERATORS = new Set(['==', '!=']);
+const ASSIGNMENT_OPERATORS = new Set(['=', '+=', '-=', '*=', '/=', '%=', '<<=', '>>=', '|=', '&=', '^=']);
+class ChainlinkTxOriginDetector {
+    id = RULE_ID;
+    patternKey = RULE_ID;
+    supportedAstKinds = ['parser', 'solc'];
+    scanAst(ast, file, sourceText) {
+        if (!ast || typeof ast !== 'object')
+            return [];
+        const findings = [];
+        const lineOffsets = (0, ast_1.buildLineOffsets)(sourceText);
+        const fileHasChainlinkImport = collectImports(ast).some(p => CHAINLINK_IMPORT_PATTERN.test(p));
+        for (const contract of collectContracts(ast)) {
+            if (isInterfaceOrLibrary(contract))
+                continue;
+            const contractName = (0, ast_1.getName)(contract) || '<anonymous>';
+            const baseNames = collectBaseContractNames(contract);
+            const functions = getContractFunctions(contract);
+            const modifiers = getContractModifiers(contract);
+            const functionNamesLower = new Set(functions.map(fn => (0, ast_1.getName)(fn).toLowerCase()));
+            const hasChainlinkBase = baseNames.some(b => CHAINLINK_BASE_CONTRACT_NAMES.has(b.toLowerCase()));
+            const hasDeprecatedFn = [...functionNamesLower].some(name => DEPRECATED_CHAINLINK_FUNCTIONS.has(name));
+            const inChainlinkContext = fileHasChainlinkImport || hasChainlinkBase || hasDeprecatedFn;
+            if (!inChainlinkContext)
+                continue;
+            const seen = new Set();
+            for (const member of [...modifiers, ...functions]) {
+                const body = getFunctionBody(member);
+                if (!body)
+                    continue;
+                const isModifier = (0, ast_1.isNode)(member, 'ModifierDefinition');
+                const memberName = isModifier
+                    ? ((0, ast_1.getName)(member) || '<anonymous>')
+                    : functionDisplayName(member);
+                const key = isModifier ? `${contractName}:modifier:${memberName}` : `${contractName}:${memberName}`;
+                if (seen.has(key))
+                    continue;
+                const candidate = findIdentitySensitiveTxOrigin(body);
+                if (!candidate)
+                    continue;
+                seen.add(key);
+                const loc = getLoc(candidate, lineOffsets) || getLoc(member, lineOffsets) || { line: 0, column: 0 };
+                const message = isModifier
+                    ? `Deprecated Chainlink integration: modifier '${contractName}.${memberName}' authorizes via tx.origin; replace tx.origin with msg.sender or an explicit access-control check.`
+                    : `Deprecated Chainlink integration in '${contractName}.${memberName}' authorizes via tx.origin; replace tx.origin with msg.sender or an explicit access-control check.`;
+                findings.push({
+                    file,
+                    contract: contractName,
+                    'function': memberName,
+                    line: loc.line,
+                    endLine: loc.line,
+                    column: loc.column,
+                    pattern: RULE_ID,
+                    confidence: 'high',
+                    ruleId: RULE_ID,
+                    severity: 'error',
+                    message,
+                    rationale: 'Chainlink documentation deprecates tx.origin in oracle integration code: tx.origin can be spoofed across reentrancy or relayed-call chains, undermining authorization, ownership checks, and request attribution.',
+                    suggestedFix: 'Replace tx.origin with msg.sender (or the recorded request originator) and gate sensitive Chainlink paths with an explicit access-control modifier rather than relying on transaction origin.',
+                    contractName,
+                    functionName: memberName,
+                    sourceLocation: { line: loc.line, column: loc.column },
+                    findingId: '',
+                    contractHash: '',
+                    provenance: PROVENANCE,
+                    source: PROVENANCE,
+                });
+            }
+        }
+        return findings;
+    }
+}
+exports.ChainlinkTxOriginDetector = ChainlinkTxOriginDetector;
+function findIdentitySensitiveTxOrigin(body) {
+    return scan(body);
+    function scan(node) {
+        if (!node || typeof node !== 'object')
+            return null;
+        if ((0, ast_1.isNode)(node, 'EmitStatement'))
+            return null;
+        if ((0, ast_1.isNode)(node, 'ReturnStatement') || (0, ast_1.isNode)(node, 'Return')) {
+            return null;
+        }
+        if (isComparisonNode(node)) {
+            const left = getBinLeft(node);
+            const right = getBinRight(node);
+            if (containsTxOrigin(left))
+                return findTxOrigin(left) || left;
+            if (containsTxOrigin(right))
+                return findTxOrigin(right) || right;
+        }
+        if (isAssignmentNode(node)) {
+            const lhs = stripTuple(getBinLeft(node));
+            const rhs = getBinRight(node);
+            if (isStorageLikeLhs(lhs) && containsTxOrigin(rhs)) {
+                return findTxOrigin(rhs) || rhs;
+            }
+        }
+        if (isFunctionCall(node)) {
+            const callee = getCalleeName(node);
+            const calleeLower = callee.toLowerCase();
+            if (calleeLower === 'require' || calleeLower === 'assert') {
+                for (const arg of getCallArguments(node)) {
+                    if (containsTxOrigin(arg))
+                        return findTxOrigin(arg) || arg;
+                }
+            }
+            if (DEPRECATED_CHAINLINK_FUNCTIONS.has(calleeLower)) {
+                for (const arg of getCallArguments(node)) {
+                    if (containsTxOrigin(arg))
+                        return findTxOrigin(arg) || arg;
+                }
+            }
+        }
+        if ((0, ast_1.isNode)(node, 'IfStatement') && containsTxOrigin(node.condition)) {
+            return findTxOrigin(node.condition) || node.condition;
+        }
+        if ((0, ast_1.isNode)(node, 'Conditional') && containsTxOrigin(node.condition)) {
+            return findTxOrigin(node.condition) || node.condition;
+        }
+        if ((0, ast_1.isNode)(node, 'RevertStatement') && node.revertCall) {
+            for (const arg of getCallArguments(node.revertCall)) {
+                if (containsTxOrigin(arg))
+                    return findTxOrigin(arg) || arg;
+            }
+        }
+        for (const child of childrenOf(node)) {
+            const found = scan(child);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+}
+function isStorageLikeLhs(lhs) {
+    return (0, ast_1.isNode)(lhs, 'IndexAccess') || (0, ast_1.isNode)(lhs, 'MemberAccess');
+}
+function isComparisonNode(node) {
+    if (!(0, ast_1.isNode)(node, 'BinaryOperation'))
+        return false;
+    return COMPARISON_OPERATORS.has(String(node.operator || ''));
+}
+function isAssignmentNode(node) {
+    if ((0, ast_1.isNode)(node, 'Assignment'))
+        return ASSIGNMENT_OPERATORS.has(String(node.operator || ''));
+    if (!(0, ast_1.isNode)(node, 'BinaryOperation'))
+        return false;
+    return ASSIGNMENT_OPERATORS.has(String(node.operator || ''));
+}
+function getBinLeft(node) {
+    return node?.left ?? node?.leftExpression ?? node?.leftHandSide ?? null;
+}
+function getBinRight(node) {
+    return node?.right ?? node?.rightExpression ?? node?.rightHandSide ?? null;
+}
+function stripTuple(node) {
+    if (!node || typeof node !== 'object')
+        return node;
+    if ((0, ast_1.isNode)(node, 'TupleExpression')) {
+        const components = (node.components || []).filter((c) => c && typeof c === 'object');
+        if (components.length === 1)
+            return stripTuple(components[0]);
+    }
+    return node;
+}
+function containsTxOrigin(node) {
+    if (!node || typeof node !== 'object')
+        return false;
+    if (isTxOrigin(node))
+        return true;
+    return childrenOf(node).some(containsTxOrigin);
+}
+function findTxOrigin(node) {
+    if (!node || typeof node !== 'object')
+        return null;
+    if (isTxOrigin(node))
+        return node;
+    for (const child of childrenOf(node)) {
+        const found = findTxOrigin(child);
+        if (found)
+            return found;
+    }
+    return null;
+}
+function isTxOrigin(node) {
+    if (!(0, ast_1.isNode)(node, 'MemberAccess'))
+        return false;
+    if (String(node.memberName || '') !== 'origin')
+        return false;
+    const expr = node.expression;
+    return (0, ast_1.isNode)(expr, 'Identifier') && String(expr.name || '') === 'tx';
+}
+function getCallArguments(node) {
+    return Array.isArray(node?.arguments) ? node.arguments : [];
+}
+function isFunctionCall(n) {
+    return (0, ast_1.isNode)(n, 'FunctionCall');
+}
+function getCalleeName(call) {
+    const callee = unwrapCallOptions(call?.expression);
+    if ((0, ast_1.isNode)(callee, 'Identifier'))
+        return String(callee.name || '');
+    if ((0, ast_1.isNode)(callee, 'MemberAccess'))
+        return String(callee.memberName || '');
+    return '';
+}
+function unwrapCallOptions(expr) {
+    if (!expr || typeof expr !== 'object')
+        return expr;
+    if ((0, ast_1.isNode)(expr, 'NameValueExpression') || (0, ast_1.isNode)(expr, 'FunctionCallOptions'))
+        return expr.expression;
+    return expr;
+}
+function collectImports(ast) {
+    const out = [];
+    walk(ast, n => {
+        if (!(0, ast_1.isNode)(n, 'ImportDirective'))
+            return;
+        const candidates = [n.path, n.absolutePath, n.file, n.pathLiteral?.value];
+        for (const c of candidates) {
+            if (typeof c === 'string' && c.length > 0) {
+                out.push(c);
+                break;
+            }
+        }
+    });
+    return out;
+}
+function collectBaseContractNames(contract) {
+    const bases = Array.isArray(contract?.baseContracts) ? contract.baseContracts : [];
+    const out = [];
+    for (const base of bases) {
+        const baseName = base?.baseName;
+        if (!baseName)
+            continue;
+        const name = baseName.namePath || baseName.name || '';
+        if (typeof name === 'string' && name.length > 0)
+            out.push(name);
+    }
+    return out;
+}
+function isInterfaceOrLibrary(contract) {
+    const kind = String(contract?.kind || contract?.contractKind || '').toLowerCase();
+    return kind === 'interface' || kind === 'library';
+}
+function getFunctionBody(node) {
+    return node?.body || null;
+}
+function getContractFunctions(contract) {
+    return getContractMembers(contract).filter(child => (0, ast_1.isNode)(child, 'FunctionDefinition'));
+}
+function getContractModifiers(contract) {
+    return getContractMembers(contract).filter(child => (0, ast_1.isNode)(child, 'ModifierDefinition'));
+}
+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 ((0, ast_1.isNode)(node, 'ContractDefinition')) {
+        visit(node);
+        return;
+    }
+    for (const child of childrenOf(node))
+        walkContracts(child, visit);
+}
+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' || 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;
+}
+function functionDisplayName(fn) {
+    const kind = String(fn?.kind || '').toLowerCase();
+    if (fn?.isFallback === true || kind === 'fallback')
+        return '<fallback>';
+    if (fn?.isReceiveEther === true || kind === 'receive')
+        return '<receive>';
+    if (fn?.isConstructor === true || kind === 'constructor')
+        return '<constructor>';
+    return (0, ast_1.getName)(fn) || '<anonymous>';
+}
+function getLoc(node, lineOffsets) {
+    if (node?.loc?.start)
+        return { line: node.loc.start.line || 0, column: node.loc.start.column || 0 };
+    if (!node?.src || !lineOffsets)
+        return undefined;
+    const [offsetRaw] = String(node.src).split(':');
+    const offset = Number(offsetRaw);
+    if (!Number.isFinite(offset) || offset < 0)
+        return undefined;
+    return (0, ast_1.byteOffsetToLineColumn)(offset, lineOffsets);
+}
+//# sourceMappingURL=chainlink-tx-origin.js.map

package/dist/detectors/check-effects-interactions.d.ts

@@ -0,0 +1,39 @@
+import type { ScanResult } from '../index';
+import type { DetectorContext } from './types';
+export declare class CheckEffectsInteractionsDetector {
+    readonly id = "check-effects-interactions";
+    readonly patternKey = "check-effects-interactions";
+    readonly supportedAstKinds: "parser"[];
+    private currentFile;
+    private typeKinds;
+    scanAst(ast: any, file: string, _sourceText?: string, ctxArg?: DetectorContext): ScanResult[];
+    private analyzeFunction;
+    private walkForCEI;
+    private isExternalCallExpression;
+    private classifyCastCallee;
+    private classifyBaseType;
+    private containsStateRead;
+    private refersToStateStorage;
+    private blockEndsWithRevertOrThrow;
+    private statementIsRevertOrThrow;
+    private summarizeInternalFunctions;
+    private bodyContainsExternalCall;
+    private functionHasReentrancyGuard;
+    private isReentrancyGuardModifierName;
+    private bodyHasInlineMutexPattern;
+    private containsStateReadInCheck;
+    private collectStateVariables;
+    private collectStateVarTypes;
+    private collectContractsByName;
+    private baseContractName;
+    private collectLocals;
+    private collectLocalTypes;
+    private harvestLocalsRecursive;
+    private harvestLocalTypesRecursive;
+    private collectTypeKinds;
+    private getDirectCallName;
+    private simpleIdentifierName;
+    private locOf;
+    private childNodes;
+    private makeFinding;
+}