@snovon/solast 0.2.0

package/dist/detectors/_common/integer-overflow-helpers.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Integer-overflow detector helpers — pragma classification, arithmetic
+ * operator vocabularies, signedness classification, expression
+ * canonicalization, and overflow/underflow guard recognizers.
+ *
+ * Extracted from `src/index.ts` per roadmap item 1.1 (split god-file
+ * into focused modules). The public API surface is unchanged —
+ * `src/index.ts` re-exports every name below so the 184 detector files
+ * importing from `'../index'` continue to see them at the same path.
+ *
+ * No external imports. Pure functions over Solidity AST node shapes.
+ * Accepts both the `@solidity-parser/parser` shape (`type` field) and
+ * the solc compact JSON shape (`nodeType` field) where relevant.
+ */
+/**
+ * Determines whether a `pragma solidity X` value permits any compiler version
+ * older than 0.8.0. v0.2 integer-overflow detection only fires for ranges that
+ * could compile under <0.8.0, since 0.8+ already inserts overflow checks.
+ *
+ * The implementation is a deliberately small semver-range parser: we extract
+ * the lower bound implied by each comparator and report whether that lower
+ * bound is below 0.8.0. Unrecognized inputs fall back to "pre-0.8 allowed"
+ * (conservative — flag rather than miss).
+ */
+export declare function pragmaAllowsPre080(pragmaValue: string): boolean;
+export declare const ARITH_OPERATORS: Set<string>;
+export declare const COMPOUND_ARITH_OPERATORS: Set<string>;
+export declare const COMPOUND_TO_BARE_ARITH: Map<string, string>;
+export declare const ARITH_DIRECTION: Map<string, "overflow" | "underflow">;
+export declare function isArithmeticBinaryOp(node: any): boolean;
+export type Signedness = 'unsigned' | 'signed' | 'unknown';
+/**
+ * Classify a Solidity AST `typeName` node as `unsigned`, `signed`, or
+ * `unknown`. Accepts both the `@solidity-parser/parser` shape (`type` field)
+ * and the solc compact JSON shape (`nodeType` field). Anything that is not a
+ * direct `uint*` or `int*` elementary type is reported as `unknown`, which
+ * the caller treats conservatively as "do not suppress".
+ */
+export declare function classifyTypeName(typeName: any): Signedness;
+/**
+ * Predicate used by guard recognizers: an arithmetic operand is treated as
+ * unsigned only when we can prove it via a tracked declaration (parameter,
+ * local, or state variable resolved as `uint*`). Unknown types are
+ * conservatively treated as not-unsigned so the eventual `BinaryOperation`
+ * is still reported.
+ */
+export type IsUnsignedFn = (expr: any) => boolean;
+export declare function isConstantExpr(expr: any): boolean;
+export declare function expressionSignature(expr: any): string;
+export declare function unwrapTuple(expr: any): any;
+/**
+ * Walk the top-level boolean shape of a `require`/`assert` argument and emit
+ * guard signatures for the recognised overflow/underflow predicates. Combines
+ * sides of `&&` (each side stands as its own guard); `||` is only honoured for
+ * the SafeMath multiplication pattern.
+ */
+export declare function collectGuardSignatures(arg: any, sigs: Set<string>, isUnsigned: IsUnsignedFn): void;
+export declare function isRequireFunctionCall(node: any): boolean;

package/dist/detectors/_common/integer-overflow-helpers.js

@@ -0,0 +1,422 @@
+"use strict";
+/**
+ * Integer-overflow detector helpers — pragma classification, arithmetic
+ * operator vocabularies, signedness classification, expression
+ * canonicalization, and overflow/underflow guard recognizers.
+ *
+ * Extracted from `src/index.ts` per roadmap item 1.1 (split god-file
+ * into focused modules). The public API surface is unchanged —
+ * `src/index.ts` re-exports every name below so the 184 detector files
+ * importing from `'../index'` continue to see them at the same path.
+ *
+ * No external imports. Pure functions over Solidity AST node shapes.
+ * Accepts both the `@solidity-parser/parser` shape (`type` field) and
+ * the solc compact JSON shape (`nodeType` field) where relevant.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ARITH_DIRECTION = exports.COMPOUND_TO_BARE_ARITH = exports.COMPOUND_ARITH_OPERATORS = exports.ARITH_OPERATORS = void 0;
+exports.pragmaAllowsPre080 = pragmaAllowsPre080;
+exports.isArithmeticBinaryOp = isArithmeticBinaryOp;
+exports.classifyTypeName = classifyTypeName;
+exports.isConstantExpr = isConstantExpr;
+exports.expressionSignature = expressionSignature;
+exports.unwrapTuple = unwrapTuple;
+exports.collectGuardSignatures = collectGuardSignatures;
+exports.isRequireFunctionCall = isRequireFunctionCall;
+/**
+ * Determines whether a `pragma solidity X` value permits any compiler version
+ * older than 0.8.0. v0.2 integer-overflow detection only fires for ranges that
+ * could compile under <0.8.0, since 0.8+ already inserts overflow checks.
+ *
+ * The implementation is a deliberately small semver-range parser: we extract
+ * the lower bound implied by each comparator and report whether that lower
+ * bound is below 0.8.0. Unrecognized inputs fall back to "pre-0.8 allowed"
+ * (conservative — flag rather than miss).
+ */
+function pragmaAllowsPre080(pragmaValue) {
+    if (!pragmaValue)
+        return true;
+    const branches = pragmaValue.split('||');
+    for (const branch of branches) {
+        const tokens = branch.trim().split(/\s+/).filter(Boolean);
+        if (tokens.length === 0)
+            return true;
+        let lowerMinor = -1;
+        let sawComparator = false;
+        for (const token of tokens) {
+            const match = token.match(/^([\^~]|>=|>|<=|<|=)?\s*0\.(\d+)(?:\.(\d+))?/);
+            if (!match)
+                continue;
+            const op = match[1] || '=';
+            const minor = parseInt(match[2], 10);
+            if (op === '<' || op === '<=')
+                continue;
+            sawComparator = true;
+            if (lowerMinor < 0 || minor > lowerMinor)
+                lowerMinor = minor;
+        }
+        if (!sawComparator)
+            return true;
+        if (lowerMinor < 8)
+            return true;
+    }
+    return false;
+}
+exports.ARITH_OPERATORS = new Set(['+', '-', '*']);
+// Compound-assignment forms of the arithmetic operators above. These are only
+// flagged when seen inside an `unchecked { ... }` block, where they share the
+// same wrap-around runtime behavior as their binary counterparts. Outside
+// `unchecked`, Solidity >=0.8.0 still inserts the overflow check, so the
+// rule stays quiet to match the existing v0.2 contract.
+exports.COMPOUND_ARITH_OPERATORS = new Set(['+=', '-=', '*=']);
+// Maps each compound arithmetic operator to the equivalent bare arithmetic
+// operator. Used to canonicalize the guard-lookup signature for `+=`/`-=`/`*=`
+// so that `require(a + b >= a); unchecked { a += b; }` matches the same
+// suppression entry as the `unchecked { a = a + b; }` form.
+exports.COMPOUND_TO_BARE_ARITH = new Map([
+    ['+=', '+'],
+    ['-=', '-'],
+    ['*=', '*']
+]);
+// Maps every flagged operator (binary or compound) to its overflow direction.
+exports.ARITH_DIRECTION = new Map([
+    ['+', 'overflow'],
+    ['-', 'underflow'],
+    ['*', 'overflow'],
+    ['+=', 'overflow'],
+    ['-=', 'underflow'],
+    ['*=', 'overflow']
+]);
+function isArithmeticBinaryOp(node) {
+    return !!node && node.type === 'BinaryOperation' && exports.ARITH_OPERATORS.has(node.operator);
+}
+/**
+ * Classify a Solidity AST `typeName` node as `unsigned`, `signed`, or
+ * `unknown`. Accepts both the `@solidity-parser/parser` shape (`type` field)
+ * and the solc compact JSON shape (`nodeType` field). Anything that is not a
+ * direct `uint*` or `int*` elementary type is reported as `unknown`, which
+ * the caller treats conservatively as "do not suppress".
+ */
+function classifyTypeName(typeName) {
+    if (!typeName || typeof typeName !== 'object')
+        return 'unknown';
+    const kind = typeName.type || typeName.nodeType;
+    if (kind !== 'ElementaryTypeName')
+        return 'unknown';
+    const name = String(typeName.name || '').toLowerCase();
+    if (name.startsWith('uint'))
+        return 'unsigned';
+    if (name.startsWith('int'))
+        return 'signed';
+    return 'unknown';
+}
+function isConstantExpr(expr) {
+    if (!expr || typeof expr !== 'object')
+        return false;
+    if (expr.type === 'NumberLiteral' || expr.type === 'HexLiteral' || expr.type === 'BooleanLiteral') {
+        return true;
+    }
+    if (expr.type === 'BinaryOperation') {
+        return isConstantExpr(expr.left) && isConstantExpr(expr.right);
+    }
+    if (expr.type === 'UnaryOperation') {
+        return isConstantExpr(expr.subExpression);
+    }
+    if (expr.type === 'TupleExpression') {
+        const components = expr.components || [];
+        return components.length > 0 && components.every((c) => c == null || isConstantExpr(c));
+    }
+    return false;
+}
+function expressionSignature(expr) {
+    if (!expr || typeof expr !== 'object')
+        return '';
+    switch (expr.type) {
+        case 'Identifier':
+            return `id:${expr.name || ''}`;
+        case 'NumberLiteral':
+            return `num:${expr.number ?? expr.value ?? ''}`;
+        case 'HexLiteral':
+            return `hex:${expr.value ?? ''}`;
+        case 'BooleanLiteral':
+            return `bool:${expr.value ?? ''}`;
+        case 'StringLiteral':
+            return `str:${expr.value ?? ''}`;
+        case 'BinaryOperation':
+            return `(${expressionSignature(expr.left)}${expr.operator}${expressionSignature(expr.right)})`;
+        case 'UnaryOperation':
+            return `${expr.operator}${expressionSignature(expr.subExpression)}`;
+        case 'MemberAccess':
+            return `${expressionSignature(expr.expression)}.${expr.memberName || ''}`;
+        case 'IndexAccess':
+            return `${expressionSignature(expr.base)}[${expressionSignature(expr.index)}]`;
+        case 'TupleExpression': {
+            const parts = (expr.components || []).map((c) => (c ? expressionSignature(c) : ''));
+            return `(${parts.join(',')})`;
+        }
+        case 'FunctionCall': {
+            const args = (expr.arguments || []).map(expressionSignature).join(',');
+            return `${expressionSignature(expr.expression)}(${args})`;
+        }
+        default:
+            return `?:${expr.type || 'unknown'}`;
+    }
+}
+function unwrapTuple(expr) {
+    while (expr &&
+        expr.type === 'TupleExpression' &&
+        Array.isArray(expr.components) &&
+        expr.components.length === 1 &&
+        expr.components[0]) {
+        expr = expr.components[0];
+    }
+    return expr;
+}
+function exprEquals(a, b) {
+    const sa = expressionSignature(unwrapTuple(a));
+    const sb = expressionSignature(unwrapTuple(b));
+    return !!sa && sa === sb;
+}
+function isZeroLiteral(expr) {
+    if (!expr || expr.type !== 'NumberLiteral')
+        return false;
+    const raw = expr.number ?? expr.value ?? '';
+    return String(raw).trim() === '0';
+}
+/**
+ * Add the signature of an arithmetic binary op to `sigs`, plus its commuted
+ * form for `+` and `*`. This is what lets `require(a + b >= a)` suppress
+ * `b + a` in the body too.
+ *
+ * The signature is only emitted when both operands are known to be unsigned
+ * integers. For signed integers, predicates like `a >= b` or `a + b >= a`
+ * do not actually rule out wrap-around (e.g. `int256.max - (-1)` overflows),
+ * so we leave the eventual `BinaryOperation` to be reported.
+ */
+function addCommutativeArithmeticSig(arith, sigs, isUnsigned) {
+    arith = unwrapTuple(arith);
+    if (!isArithmeticBinaryOp(arith))
+        return;
+    const left = unwrapTuple(arith.left);
+    const right = unwrapTuple(arith.right);
+    if (!isUnsigned(left) || !isUnsigned(right))
+        return;
+    const sig = `(${expressionSignature(left)}${arith.operator}${expressionSignature(right)})`;
+    if (sig)
+        sigs.add(sig);
+    if (arith.operator === '+' || arith.operator === '*') {
+        const commuted = `(${expressionSignature(right)}${arith.operator}${expressionSignature(left)})`;
+        if (commuted)
+            sigs.add(commuted);
+    }
+}
+/**
+ * Recognise an addition overflow guard from a relational predicate.
+ * Accepted shapes (commutative on the addition operands):
+ *   (a + b) >= a, (a + b) >= b, (a + b) > a, (a + b) > b
+ *   a <= (a + b), b <= (a + b), a < (a + b), b < (a + b)
+ * Rejects ineffective predicates like `(a + b) > 0`.
+ */
+function recognizeAdditionOverflowGuard(pred, sigs, isUnsigned) {
+    if (!pred || pred.type !== 'BinaryOperation')
+        return;
+    const op = pred.operator;
+    const lhs = unwrapTuple(pred.left);
+    const rhs = unwrapTuple(pred.right);
+    if (op === '>=' || op === '>') {
+        if (isArithmeticBinaryOp(lhs) && lhs.operator === '+') {
+            if (exprEquals(lhs.left, rhs) || exprEquals(lhs.right, rhs)) {
+                addCommutativeArithmeticSig(lhs, sigs, isUnsigned);
+            }
+        }
+    }
+    if (op === '<=' || op === '<') {
+        if (isArithmeticBinaryOp(rhs) && rhs.operator === '+') {
+            if (exprEquals(rhs.left, lhs) || exprEquals(rhs.right, lhs)) {
+                addCommutativeArithmeticSig(rhs, sigs, isUnsigned);
+            }
+        }
+    }
+}
+/**
+ * Recognise a subtraction underflow guard.
+ *
+ * Pre-checks (no `-` in the predicate, the eventual `a - b` is constructed):
+ *   a >= b, a > b, b <= a, b < a
+ *
+ * Post-checks (the subtraction itself appears in the predicate):
+ *   (a - b) <= a, (a - b) < a, a >= (a - b), a > (a - b)
+ *
+ * Rejects ineffective predicates like `(a - b) >= 0` (always true on uint).
+ */
+function recognizeSubtractionUnderflowGuard(pred, sigs, isUnsigned) {
+    if (!pred || pred.type !== 'BinaryOperation')
+        return;
+    const op = pred.operator;
+    const lhs = unwrapTuple(pred.left);
+    const rhs = unwrapTuple(pred.right);
+    // Post-check forms first — they take precedence when `-` appears.
+    if (op === '<=' || op === '<') {
+        if (isArithmeticBinaryOp(lhs) && lhs.operator === '-') {
+            if (exprEquals(lhs.left, rhs)) {
+                addCommutativeArithmeticSig(lhs, sigs, isUnsigned);
+            }
+            return;
+        }
+    }
+    if (op === '>=' || op === '>') {
+        if (isArithmeticBinaryOp(rhs) && rhs.operator === '-') {
+            if (exprEquals(rhs.left, lhs)) {
+                addCommutativeArithmeticSig(rhs, sigs, isUnsigned);
+            }
+            return;
+        }
+    }
+    // Pre-check forms: a >= b, a > b → guard for a - b. The eventual `a - b`
+    // is unsigned-safe under this predicate ONLY when both operands are
+    // declared unsigned; for signed integers, `int256.max >= -1` holds yet
+    // `int256.max - (-1)` still overflows.
+    if (op === '>=' || op === '>') {
+        if (!isArithmeticBinaryOp(lhs) && !isArithmeticBinaryOp(rhs)) {
+            if (!isUnsigned(lhs) || !isUnsigned(rhs))
+                return;
+            const ls = expressionSignature(lhs);
+            const rs = expressionSignature(rhs);
+            if (ls && rs)
+                sigs.add(`(${ls}-${rs})`);
+        }
+        return;
+    }
+    // b <= a, b < a → guard for a - b (operands swapped).
+    if (op === '<=' || op === '<') {
+        if (!isArithmeticBinaryOp(lhs) && !isArithmeticBinaryOp(rhs)) {
+            if (!isUnsigned(lhs) || !isUnsigned(rhs))
+                return;
+            const ls = expressionSignature(lhs);
+            const rs = expressionSignature(rhs);
+            if (ls && rs)
+                sigs.add(`(${rs}-${ls})`);
+        }
+    }
+}
+/**
+ * Recognise a multiplication overflow guard. Two accepted shapes:
+ *   (a * b) <= MAX, (a * b) < MAX, MAX >= (a * b), MAX > (a * b)
+ *   a == 0 || (a * b) / a == b   (and commutative variants)
+ * Rejects ineffective predicates like `(a * b) != 0`.
+ */
+function recognizeMultiplicationOverflowGuard(pred, sigs, isUnsigned) {
+    if (!pred || pred.type !== 'BinaryOperation')
+        return;
+    const op = pred.operator;
+    const lhs = unwrapTuple(pred.left);
+    const rhs = unwrapTuple(pred.right);
+    if (op === '<=' || op === '<') {
+        if (isArithmeticBinaryOp(lhs) && lhs.operator === '*') {
+            addCommutativeArithmeticSig(lhs, sigs, isUnsigned);
+            return;
+        }
+    }
+    if (op === '>=' || op === '>') {
+        if (isArithmeticBinaryOp(rhs) && rhs.operator === '*') {
+            addCommutativeArithmeticSig(rhs, sigs, isUnsigned);
+        }
+    }
+}
+/**
+ * Recognise the SafeMath multiplication guard `a == 0 || (a * b) / a == b`,
+ * accepting both orderings of the `||` and the equality, plus the commutative
+ * `b * a`. Returns true if a guard signature was added.
+ */
+function recognizeMultiplicationOrGuard(orPred, sigs, isUnsigned) {
+    if (!orPred || orPred.type !== 'BinaryOperation' || orPred.operator !== '||')
+        return false;
+    const sides = [unwrapTuple(orPred.left), unwrapTuple(orPred.right)];
+    let zeroVar = null;
+    let divEq = null;
+    for (const side of sides) {
+        if (side?.type === 'BinaryOperation' && side.operator === '==') {
+            const sl = unwrapTuple(side.left);
+            const sr = unwrapTuple(side.right);
+            if (isZeroLiteral(sr)) {
+                zeroVar = sl;
+                continue;
+            }
+            if (isZeroLiteral(sl)) {
+                zeroVar = sr;
+                continue;
+            }
+        }
+        divEq = side;
+    }
+    if (!zeroVar || !divEq)
+        return false;
+    if (divEq.type !== 'BinaryOperation' || divEq.operator !== '==')
+        return false;
+    // One side of `==` must be a `/` over a `*`; the other side is the partner operand.
+    const eqSides = [unwrapTuple(divEq.left), unwrapTuple(divEq.right)];
+    let divExpr = null;
+    let partner = null;
+    for (const s of eqSides) {
+        if (s?.type === 'BinaryOperation' && s.operator === '/')
+            divExpr = s;
+        else
+            partner = s;
+    }
+    if (!divExpr || !partner)
+        return false;
+    const mul = unwrapTuple(divExpr.left);
+    const divisor = unwrapTuple(divExpr.right);
+    if (!isArithmeticBinaryOp(mul) || mul.operator !== '*')
+        return false;
+    if (!exprEquals(divisor, zeroVar))
+        return false;
+    // Partner must equal the OTHER multiplicand.
+    if (exprEquals(divisor, mul.left) && exprEquals(partner, mul.right)) {
+        addCommutativeArithmeticSig(mul, sigs, isUnsigned);
+        return true;
+    }
+    if (exprEquals(divisor, mul.right) && exprEquals(partner, mul.left)) {
+        addCommutativeArithmeticSig(mul, sigs, isUnsigned);
+        return true;
+    }
+    return false;
+}
+/**
+ * Walk the top-level boolean shape of a `require`/`assert` argument and emit
+ * guard signatures for the recognised overflow/underflow predicates. Combines
+ * sides of `&&` (each side stands as its own guard); `||` is only honoured for
+ * the SafeMath multiplication pattern.
+ */
+function collectGuardSignatures(arg, sigs, isUnsigned) {
+    arg = unwrapTuple(arg);
+    if (!arg || typeof arg !== 'object')
+        return;
+    if (arg.type === 'StringLiteral')
+        return;
+    if (arg.type === 'BinaryOperation' && arg.operator === '&&') {
+        collectGuardSignatures(arg.left, sigs, isUnsigned);
+        collectGuardSignatures(arg.right, sigs, isUnsigned);
+        return;
+    }
+    if (arg.type === 'BinaryOperation' && arg.operator === '||') {
+        recognizeMultiplicationOrGuard(arg, sigs, isUnsigned);
+        return;
+    }
+    recognizeAdditionOverflowGuard(arg, sigs, isUnsigned);
+    recognizeSubtractionUnderflowGuard(arg, sigs, isUnsigned);
+    recognizeMultiplicationOverflowGuard(arg, sigs, isUnsigned);
+}
+function isRequireFunctionCall(node) {
+    if (!node || node.type !== 'FunctionCall')
+        return false;
+    const callee = node.expression;
+    if (!callee)
+        return false;
+    if (callee.type === 'Identifier') {
+        const name = callee.name || '';
+        return name === 'require' || name === 'assert';
+    }
+    return false;
+}
+//# sourceMappingURL=integer-overflow-helpers.js.map

package/dist/detectors/_common/loop-call-stack.d.ts

@@ -0,0 +1,9 @@
+export interface LoopCallStackEnrichment {
+    callPath: string;
+    messageSuffix: string;
+}
+export declare function enrichLoopCallStack(finding: {
+    message: string;
+    callPath?: string;
+}, callPath: string | null): void;
+export declare function loopCallPathForFunction(contractNode: any, targetFunctionNode: any): string | null;

package/dist/detectors/_common/loop-call-stack.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enrichLoopCallStack = enrichLoopCallStack;
+exports.loopCallPathForFunction = loopCallPathForFunction;
+const MAX_CALL_DEPTH = 16;
+function enrichLoopCallStack(finding, callPath) {
+    if (!callPath)
+        return;
+    finding.callPath = callPath;
+    finding.message = `${finding.message} Loop call stack: ${callPath}`;
+}
+function loopCallPathForFunction(contractNode, targetFunctionNode) {
+    const targetName = functionName(targetFunctionNode);
+    if (!targetName)
+        return null;
+    const functions = collectFunctions(contractNode);
+    if (!functions.has(targetName))
+        return null;
+    const ancestorStarts = Array.from(functions.values()).filter((fn) => fn.name !== targetName && fn.reachableFromOutside && canReach(fn.name, targetName, functions));
+    const starts = ancestorStarts.length > 0
+        ? ancestorStarts
+        : Array.from(functions.values()).filter((fn) => fn.name === targetName && fn.reachableFromOutside);
+    for (const start of starts) {
+        const path = findPath(start.name, targetName, functions);
+        if (path)
+            return path.join(' -> ');
+    }
+    return null;
+}
+function collectFunctions(contractNode) {
+    const functions = new Map();
+    for (const node of contractNode?.subNodes || []) {
+        if (node?.type !== 'FunctionDefinition' || !node.body)
+            continue;
+        const name = functionName(node);
+        if (!name)
+            continue;
+        functions.set(name, {
+            name,
+            node,
+            calls: collectSameContractCalls(node.body),
+            reachableFromOutside: isExternallyReachable(node),
+        });
+    }
+    return functions;
+}
+function findPath(start, target, functions) {
+    const queue = [[start]];
+    const seen = new Set();
+    while (queue.length > 0) {
+        const path = queue.shift();
+        const current = path[path.length - 1];
+        if (current === target)
+            return path;
+        if (seen.has(current))
+            continue;
+        seen.add(current);
+        if (path.length >= MAX_CALL_DEPTH)
+            continue;
+        const fn = functions.get(current);
+        if (!fn)
+            continue;
+        for (const callee of fn.calls) {
+            if (!functions.has(callee))
+                continue;
+            if (path.includes(callee) && callee !== target)
+                continue;
+            queue.push([...path, callee]);
+        }
+    }
+    return null;
+}
+function canReach(start, target, functions) {
+    return findPath(start, target, functions) !== null;
+}
+function collectSameContractCalls(root) {
+    const calls = [];
+    const visit = (node) => {
+        if (!node || typeof node !== 'object')
+            return;
+        if (node.type === 'FunctionCall') {
+            const name = sameContractCallName(node);
+            if (name)
+                calls.push(name);
+        }
+        for (const child of childNodes(node))
+            visit(child);
+    };
+    visit(root);
+    return calls;
+}
+function sameContractCallName(call) {
+    const expr = call?.expression;
+    if (expr?.type === 'Identifier')
+        return String(expr.name || '') || null;
+    if (expr?.type === 'MemberAccess' && expr.memberName && expr.expression?.type === 'Identifier' && expr.expression.name === 'this') {
+        return String(expr.memberName);
+    }
+    return null;
+}
+function functionName(node) {
+    const name = String(node?.name || '');
+    if (name)
+        return name;
+    if (node?.isConstructor || String(node?.kind || '').toLowerCase() === 'constructor')
+        return '<constructor>';
+    return null;
+}
+function isExternallyReachable(node) {
+    if (node?.isConstructor || String(node?.kind || '').toLowerCase() === 'constructor')
+        return false;
+    const visibility = String(node?.visibility || '').toLowerCase();
+    return visibility === 'public' || visibility === 'external' || visibility === 'default' || visibility === '';
+}
+function childNodes(node) {
+    const children = [];
+    for (const [key, value] of Object.entries(node || {})) {
+        if (key === 'loc' || key === 'range')
+            continue;
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (item && typeof item === 'object')
+                    children.push(item);
+            }
+        }
+        else if (value && typeof value === 'object') {
+            children.push(value);
+        }
+    }
+    return children;
+}
+//# sourceMappingURL=loop-call-stack.js.map

package/dist/detectors/_common/oracle.d.ts

@@ -0,0 +1,5 @@
+export declare const AMM_SPOT_SOURCES: ReadonlySet<string>;
+export declare const TWAP_CALLS: ReadonlySet<string>;
+export declare const SINK_CALL_NAMES: Set<string>;
+export declare const LIQUIDITY_WITHDRAWAL_CALL_NAMES: Set<string>;
+export declare function isLiquidityWithdrawalCall(callNode: any, getCalleeName: (expr: any) => string): boolean;