@snovon/solast 0.2.0

package/dist/detectors/division-before-multiplication.d.ts

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

package/dist/detectors/division-before-multiplication.js

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DivisionBeforeMultiplicationDetector = void 0;
+const RULE_ID = 'division-before-multiplication';
+class DivisionBeforeMultiplicationDetector {
+    id = RULE_ID;
+    patternKey = RULE_ID;
+    supportedAstKinds = ['parser', 'solc'];
+    scanAst(ast, file, sourceText) {
+        if (!ast || typeof ast !== 'object')
+            return [];
+        const findings = [];
+        const lineOffsets = buildLineOffsets(sourceText);
+        walk(ast, {}, (node, context) => {
+            if (!isBinary(node, '*'))
+                return;
+            if (isConstantExpression(node))
+                return;
+            if (!hasRiskyDivision(getLeft(node)) && !hasRiskyDivision(getRight(node)))
+                return;
+            if (hasRiskyMultiplication(getLeft(node)) || hasRiskyMultiplication(getRight(node)))
+                return;
+            findings.push(buildFinding(file, node, lineOffsets, {
+                contractName: context.contractName || '',
+                functionName: context.functionName || '',
+            }, sourceText));
+        });
+        return findings;
+    }
+}
+exports.DivisionBeforeMultiplicationDetector = DivisionBeforeMultiplicationDetector;
+function walk(node, context, visit) {
+    if (!node || typeof node !== 'object')
+        return;
+    const nextContext = updateContext(node, context);
+    visit(node, nextContext);
+    for (const child of childrenOf(node)) {
+        walk(child, nextContext, visit);
+    }
+}
+function updateContext(node, context) {
+    if (isNode(node, 'ContractDefinition')) {
+        return {
+            ...context,
+            contractName: getName(node),
+        };
+    }
+    if (isNode(node, 'FunctionDefinition')) {
+        return {
+            ...context,
+            functionName: getName(node),
+        };
+    }
+    return context;
+}
+function buildFinding(file, node, lineOffsets, context, sourceText) {
+    const loc = getLoc(node, lineOffsets);
+    const endLoc = getEndLoc(node, lineOffsets);
+    const line = loc?.line || 0;
+    const column = loc?.column || 0;
+    const endLine = endLoc?.line || line;
+    const endColumn = endLoc?.column;
+    const source = sourceText ? getSourceSnippet(node, sourceText) : undefined;
+    return {
+        file,
+        contract: context.contractName,
+        'function': context.functionName,
+        line,
+        endLine,
+        column,
+        endColumn,
+        pattern: RULE_ID,
+        confidence: 'high',
+        ruleId: RULE_ID,
+        severity: 'low',
+        message: `Division before multiplication in function '${context.functionName}' can magnify Solidity integer truncation and cause precision loss.`,
+        contractName: context.contractName,
+        functionName: context.functionName,
+        sourceLocation: { line, column },
+        trace: 'division-before-later-multiplication',
+        findingId: '',
+        contractHash: '',
+        source,
+    };
+}
+function isBinary(node, operator) {
+    return isNode(node, 'BinaryOperation') && getOperator(node) === operator;
+}
+function getLeft(node) {
+    return node?.left ?? node?.leftExpression;
+}
+function getRight(node) {
+    return node?.right ?? node?.rightExpression;
+}
+function getOperator(node) {
+    return node?.operator || '';
+}
+function hasRiskyMultiplication(node) {
+    const current = unwrapExpression(node);
+    if (!current || typeof current !== 'object')
+        return false;
+    if (isBinary(current, '*') && !isConstantExpression(current) && (hasRiskyDivision(getLeft(current)) || hasRiskyDivision(getRight(current)))) {
+        return true;
+    }
+    return expressionChildrenOf(current).some(hasRiskyMultiplication);
+}
+function hasRiskyDivision(node) {
+    const current = unwrapExpression(node);
+    if (!current || typeof current !== 'object')
+        return false;
+    if (isBinary(current, '/')) {
+        return !isSafeDivision(current);
+    }
+    return expressionChildrenOf(current).some(hasRiskyDivision);
+}
+function isSafeDivision(node) {
+    const numerator = unwrapExpression(getLeft(node));
+    const denominator = unwrapExpression(getRight(node));
+    if (isConstantExpression(node))
+        return true;
+    if (isNumericLiteral(denominator, '1'))
+        return true;
+    if (containsMultiplicativeFactor(numerator, denominator))
+        return true;
+    return false;
+}
+function containsMultiplicativeFactor(node, factor) {
+    const current = unwrapExpression(node);
+    const expected = expressionKey(factor);
+    if (!current || !expected)
+        return false;
+    if (expressionKey(current) === expected)
+        return true;
+    if (isBinary(current, '*')) {
+        return containsMultiplicativeFactor(getLeft(current), factor) || containsMultiplicativeFactor(getRight(current), factor);
+    }
+    return false;
+}
+function expressionChildrenOf(node) {
+    const current = unwrapExpression(node);
+    if (!current || typeof current !== 'object')
+        return [];
+    if (isNode(current, 'BinaryOperation')) {
+        return [getLeft(current), getRight(current)].filter(Boolean);
+    }
+    if (isNode(current, 'Conditional')) {
+        return [current.condition, current.trueExpression, current.falseExpression].filter(Boolean);
+    }
+    if (isNode(current, 'UnaryOperation')) {
+        return [current.subExpression].filter(Boolean);
+    }
+    if (isNode(current, 'FunctionCall')) {
+        return [current.expression, ...(current.arguments || [])].filter(Boolean);
+    }
+    if (isNode(current, 'IndexAccess')) {
+        return [current.base, current.index, current.baseExpression, current.indexExpression].filter(Boolean);
+    }
+    if (isNode(current, 'MemberAccess')) {
+        return [current.expression].filter(Boolean);
+    }
+    return [];
+}
+function isConstantExpression(node) {
+    const current = unwrapExpression(node);
+    if (!current || typeof current !== 'object')
+        return false;
+    if (isLiteral(current))
+        return true;
+    if (isNode(current, 'BinaryOperation')) {
+        return isConstantExpression(getLeft(current)) && isConstantExpression(getRight(current));
+    }
+    if (isNode(current, 'UnaryOperation')) {
+        return isConstantExpression(current.subExpression);
+    }
+    return false;
+}
+function isLiteral(node) {
+    return isNode(node, 'NumberLiteral') || isNode(node, 'BooleanLiteral') || isNode(node, 'StringLiteral') || isNode(node, 'HexLiteral') || isNode(node, 'Literal');
+}
+function isNumericLiteral(node, expected) {
+    const current = unwrapExpression(node);
+    const value = current?.number ?? current?.value ?? current?.hexValue;
+    return isLiteral(current) && String(value) === expected;
+}
+function expressionKey(node) {
+    const current = unwrapExpression(node);
+    if (!current || typeof current !== 'object')
+        return '';
+    if (isNode(current, 'Identifier')) {
+        return `id:${current.name || ''}`;
+    }
+    if (isLiteral(current)) {
+        const value = current.number ?? current.value ?? current.hexValue ?? '';
+        return `lit:${value}`;
+    }
+    if (isNode(current, 'MemberAccess')) {
+        return `member:${expressionKey(current.expression)}.${current.memberName || ''}`;
+    }
+    if (isNode(current, 'IndexAccess')) {
+        return `index:${expressionKey(current.base || current.baseExpression)}[${expressionKey(current.index || current.indexExpression)}]`;
+    }
+    if (isNode(current, 'BinaryOperation')) {
+        return `bin:${getOperator(current)}(${expressionKey(getLeft(current))},${expressionKey(getRight(current))})`;
+    }
+    return '';
+}
+function unwrapExpression(node) {
+    let current = node;
+    while (isNode(current, 'TupleExpression')) {
+        const components = current?.components;
+        if (!Array.isArray(components) || components.length !== 1)
+            break;
+        current = components[0];
+    }
+    return current;
+}
+function isNode(node, kind) {
+    return node?.type === kind || node?.nodeType === kind;
+}
+function getName(node) {
+    return node?.name || '';
+}
+function childrenOf(node) {
+    if (!node || typeof node !== 'object')
+        return [];
+    const children = [];
+    for (const [key, value] of Object.entries(node)) {
+        if (key === 'loc' || key === 'src' || key === 'range' || key === 'typeDescriptions')
+            continue;
+        if (Array.isArray(value)) {
+            children.push(...value.filter(item => item && typeof item === 'object'));
+        }
+        else if (value && typeof value === 'object') {
+            children.push(value);
+        }
+    }
+    return children;
+}
+function buildLineOffsets(sourceText) {
+    if (sourceText === undefined)
+        return undefined;
+    const lineOffsets = [0];
+    let byteOffset = 0;
+    for (const char of sourceText) {
+        byteOffset += Buffer.byteLength(char, 'utf8');
+        if (char === '\n')
+            lineOffsets.push(byteOffset);
+    }
+    return lineOffsets;
+}
+function getLoc(node, lineOffsets) {
+    if (node?.loc?.start)
+        return node.loc.start;
+    if (!node?.src || !lineOffsets)
+        return undefined;
+    const offset = Number(String(node.src).split(':')[0]);
+    if (!Number.isFinite(offset) || offset < 0)
+        return undefined;
+    let lineIndex = 0;
+    for (let i = 0; i < lineOffsets.length; i++) {
+        if (lineOffsets[i] <= offset)
+            lineIndex = i;
+        else
+            break;
+    }
+    return { line: lineIndex + 1, column: offset - lineOffsets[lineIndex] };
+}
+function getEndLoc(node, lineOffsets) {
+    if (node?.loc?.end) {
+        return node.loc.end;
+    }
+    const range = getSourceRange(node);
+    if (!range || !lineOffsets)
+        return undefined;
+    let lineIndex = 0;
+    for (let i = 0; i < lineOffsets.length; i++) {
+        if (lineOffsets[i] <= range.end)
+            lineIndex = i;
+        else
+            break;
+    }
+    return { line: lineIndex + 1, column: range.end - lineOffsets[lineIndex] };
+}
+function getSourceSnippet(node, sourceText) {
+    const range = getSourceRange(node);
+    if (!range)
+        return undefined;
+    return sourceText.slice(range.start, range.end);
+}
+function getSourceRange(node) {
+    if (Array.isArray(node?.range) && node.range.length >= 2) {
+        return { start: Number(node.range[0]), end: Number(node.range[1]) + 1 };
+    }
+    if (!node?.src)
+        return undefined;
+    const [startText, lengthText] = String(node.src).split(':');
+    const start = Number(startText);
+    const length = Number(lengthText);
+    if (!Number.isFinite(start) || !Number.isFinite(length) || start < 0 || length < 0)
+        return undefined;
+    return { start, end: start + length };
+}
+//# sourceMappingURL=division-before-multiplication.js.map

package/dist/detectors/dn404-mirror-access-control.d.ts

@@ -0,0 +1,26 @@
+import type { ScanResult } from '../index';
+export declare class Dn404MirrorAccessControlDetector {
+    readonly id = "dn404-mirror-access-control";
+    readonly patternKey = "dn404-mirror-access-control";
+    readonly supportedAstKinds: "parser"[];
+    readonly descriptor: {
+        id: string;
+        shortDescription: string;
+        helpUri: string;
+        defaultSeverity: "high";
+        help: string;
+    };
+    private file;
+    private findings;
+    private current;
+    setFile(file: string): void;
+    getFindings(): ScanResult[];
+    ContractDefinition(node: any): void;
+    ['ContractDefinition:exit'](): void;
+    StateVariableDeclaration(node: any): void;
+    ModifierDefinition(node: any): void;
+    FunctionDefinition(node: any): void;
+    private analyzeContract;
+    private isDn404MirrorSurface;
+    private hasBaseCallerGuardBeforeMutation;
+}

package/dist/detectors/dn404-mirror-access-control.js

@@ -0,0 +1,315 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dn404MirrorAccessControlDetector = void 0;
+const ast_1 = require("./_common/ast");
+const access_control_1 = require("./_common/access-control");
+const RULE_ID = 'dn404-mirror-access-control';
+const MIRROR_HOOKS = new Set(['transferFromNFT', 'approveNFT', 'setApprovalForAll']);
+const DN404_SPECIFIC_HOOKS = new Set(['transferFromNFT', 'approveNFT']);
+const MIRROR_MUTATOR_CALLS = new Set(['_transfer', '_approve', '_setApprovalForAll']);
+const ASSIGNMENT_OPERATORS = new Set([
+    '=', '+=', '-=', '*=', '/=', '%=', '&=', '|=', '^=', '<<=', '>>=', '>>>=',
+]);
+class Dn404MirrorAccessControlDetector {
+    id = RULE_ID;
+    patternKey = RULE_ID;
+    supportedAstKinds = ['parser'];
+    descriptor = {
+        id: RULE_ID,
+        shortDescription: 'DN404 mirror hook missing paired-base caller guard.',
+        helpUri: 'https://snovon.com/',
+        defaultSeverity: 'high',
+        help: 'Flags DN404 mirror transfer and approval hooks that mutate NFT mirror state before checking the caller is the paired base/ERC20 contract.',
+    };
+    file = '';
+    findings = [];
+    current = null;
+    setFile(file) {
+        this.file = file;
+        this.findings = [];
+        this.current = null;
+    }
+    getFindings() {
+        return this.findings;
+    }
+    ContractDefinition(node) {
+        const name = (0, ast_1.getName)(node);
+        const cues = new Set();
+        if (name.toLowerCase().includes('dn404'))
+            cues.add('contract-name');
+        if (name.toLowerCase().includes('mirror'))
+            cues.add('mirror-name');
+        this.current = {
+            node,
+            name,
+            kind: String(node.kind || node.contractKind || '').toLowerCase(),
+            stateVars: new Set(),
+            functions: [],
+            modifiers: new Map(),
+            dn404Cues: cues,
+        };
+    }
+    ['ContractDefinition:exit']() {
+        if (this.current)
+            this.analyzeContract(this.current);
+        this.current = null;
+    }
+    StateVariableDeclaration(node) {
+        if (!this.current)
+            return;
+        for (const variable of node.variables || []) {
+            const name = (0, ast_1.getName)(variable);
+            if (!name)
+                continue;
+            this.current.stateVars.add(name);
+            if (isDn404BaseName(name))
+                this.current.dn404Cues.add('base-state');
+        }
+    }
+    ModifierDefinition(node) {
+        if (!this.current)
+            return;
+        const name = (0, ast_1.getName)(node);
+        if (name)
+            this.current.modifiers.set(name, node);
+    }
+    FunctionDefinition(node) {
+        if (!this.current)
+            return;
+        const name = (0, ast_1.getName)(node);
+        this.current.functions.push(node);
+        if (name === 'linkMirrorContract' || name === '_getDN404Storage' || name === 'sisterERC20') {
+            this.current.dn404Cues.add(name);
+        }
+    }
+    analyzeContract(contract) {
+        if (contract.kind === 'interface' || contract.kind === 'library')
+            return;
+        for (const fn of contract.functions) {
+            const functionName = (0, ast_1.getName)(fn);
+            if (!MIRROR_HOOKS.has(functionName))
+                continue;
+            if (!isExternallyCallable(fn))
+                continue;
+            if (isReadOnly(fn))
+                continue;
+            if (!fn.body)
+                continue;
+            if (!this.isDn404MirrorSurface(contract, functionName))
+                continue;
+            const mutation = firstMirrorMutation(fn.body, contract.stateVars);
+            if (!mutation)
+                continue;
+            if (this.hasBaseCallerGuardBeforeMutation(fn, contract, mutation))
+                continue;
+            const loc = (0, ast_1.assertLoc)(fn, contract.node);
+            this.findings.push({
+                file: this.file,
+                contract: contract.name || '<anonymous>',
+                'function': functionName || '<anonymous>',
+                line: loc.line,
+                endLine: loc.endLine,
+                column: loc.column,
+                pattern: RULE_ID,
+                confidence: 'high',
+                ruleId: RULE_ID,
+                severity: 'high',
+                message: `DN404 mirror access-control gap in '${contract.name}.${functionName}': externally callable mirror hook mutates NFT state before requiring the paired base/ERC20 contract as caller.`,
+                rationale: 'Matches the filx-class DN404 mirror failure where transfer or approval hooks are callable by arbitrary accounts instead of being gated to the paired base/ERC20 contract.',
+                suggestedFix: 'Require msg.sender, _msgSender(), or an equivalent caller identity to equal the paired base/ERC20 address before the mirror state mutation; put the guard in the hook or in a modifier that executes before the hook body.',
+                contractName: contract.name || '<anonymous>',
+                functionName: functionName || '<anonymous>',
+                sourceLocation: { line: loc.line, column: loc.column },
+                findingId: '',
+                contractHash: '',
+            });
+        }
+    }
+    isDn404MirrorSurface(contract, functionName) {
+        if (DN404_SPECIFIC_HOOKS.has(functionName))
+            return true;
+        return contract.dn404Cues.size > 0;
+    }
+    hasBaseCallerGuardBeforeMutation(fn, contract, mutation) {
+        if ((0, access_control_1.hasRecognisedAccessControlModifier)(fn))
+            return true;
+        for (const modifier of fn.modifiers || []) {
+            const modifierName = getModifierName(modifier);
+            const modifierDefinition = modifierName ? contract.modifiers.get(modifierName) : null;
+            if (modifierDefinition && modifierHasBaseCallerGuardBeforePlaceholder(modifierDefinition))
+                return true;
+        }
+        return blockHasBaseCallerGuardBeforeMutation(fn.body, mutation);
+    }
+}
+exports.Dn404MirrorAccessControlDetector = Dn404MirrorAccessControlDetector;
+function isExternallyCallable(fn) {
+    const kind = String(fn.kind || fn.functionKind || '').toLowerCase();
+    if (kind === 'constructor' || fn.isConstructor)
+        return false;
+    const visibility = String(fn.visibility || '').toLowerCase();
+    return visibility === 'public' || visibility === 'external';
+}
+function isReadOnly(fn) {
+    const mutability = String(fn.stateMutability || '').toLowerCase();
+    return mutability === 'view' || mutability === 'pure';
+}
+function firstMirrorMutation(body, stateVars) {
+    for (const stmt of getStatements(body)) {
+        const mutation = findFirst(stmt, node => isMirrorMutation(node, stateVars));
+        if (mutation)
+            return mutation;
+    }
+    return null;
+}
+function blockHasBaseCallerGuardBeforeMutation(body, mutation) {
+    for (const stmt of getStatements(body)) {
+        if (containsNode(stmt, mutation))
+            return false;
+        if (statementIsBaseCallerGuard(stmt))
+            return true;
+    }
+    return false;
+}
+function modifierHasBaseCallerGuardBeforePlaceholder(modifier) {
+    for (const stmt of getStatements(modifier.body)) {
+        if ((0, ast_1.isNode)(stmt, 'PlaceholderStatement'))
+            return false;
+        if (statementIsBaseCallerGuard(stmt))
+            return true;
+    }
+    return false;
+}
+function statementIsBaseCallerGuard(stmt) {
+    if (!(0, ast_1.isNode)(stmt, 'ExpressionStatement'))
+        return false;
+    const expr = stmt.expression;
+    if (!(0, ast_1.isNode)(expr, 'FunctionCall'))
+        return false;
+    const callee = getCalleeName(expr.expression).toLowerCase();
+    if (callee !== 'require' && callee !== 'assert')
+        return false;
+    return (expr.arguments || []).some((arg) => conditionExpressesBaseCallerGuard(arg));
+}
+function conditionExpressesBaseCallerGuard(expr) {
+    if ((0, access_control_1.requireExpressesAccessControl)(expr, isDn404BaseName))
+        return true;
+    if (!expr || typeof expr !== 'object')
+        return false;
+    if ((0, ast_1.isNode)(expr, 'BinaryOperation') && (expr.operator === '==' || expr.operator === '===')) {
+        const left = expr.left || expr.leftExpression;
+        const right = expr.right || expr.rightExpression;
+        if ((0, access_control_1.isCallerIdentityExpression)(left) && (0, access_control_1.isPrivilegedReference)(right, isDn404BaseName))
+            return true;
+        if ((0, access_control_1.isCallerIdentityExpression)(right) && (0, access_control_1.isPrivilegedReference)(left, isDn404BaseName))
+            return true;
+    }
+    if ((0, ast_1.isNode)(expr, 'BinaryOperation') && (expr.operator === '&&' || expr.operator === '||')) {
+        return conditionExpressesBaseCallerGuard(expr.left || expr.leftExpression)
+            || conditionExpressesBaseCallerGuard(expr.right || expr.rightExpression);
+    }
+    if ((0, ast_1.isNode)(expr, 'TupleExpression')) {
+        return (expr.components || []).some((child) => conditionExpressesBaseCallerGuard(child));
+    }
+    return false;
+}
+function isDn404BaseName(name) {
+    const normalized = name.replace(/^_+/, '').toLowerCase();
+    return normalized === 'base'
+        || normalized === 'baseerc20'
+        || normalized === 'sistererc20'
+        || normalized === 'dn404'
+        || normalized === 'erc20';
+}
+function isMirrorMutation(node, stateVars) {
+    if (isAssignment(node)) {
+        const root = assignmentRootName(node.left || node.leftExpression || node.leftHandSide);
+        return stateVars.size === 0 ? Boolean(root) : stateVars.has(root);
+    }
+    if ((0, ast_1.isNode)(node, 'UnaryOperation') && (node.operator === '++' || node.operator === '--' || node.operator === 'delete')) {
+        const root = assignmentRootName(node.subExpression);
+        return stateVars.size === 0 ? Boolean(root) : stateVars.has(root);
+    }
+    if ((0, ast_1.isNode)(node, 'FunctionCall')) {
+        return MIRROR_MUTATOR_CALLS.has(getCalleeName(node.expression));
+    }
+    return false;
+}
+function isAssignment(node) {
+    if (!(0, ast_1.isNode)(node, 'BinaryOperation') && !(0, ast_1.isNode)(node, 'Assignment'))
+        return false;
+    return ASSIGNMENT_OPERATORS.has(String(node.operator || ''));
+}
+function assignmentRootName(node) {
+    if (!node || typeof node !== 'object')
+        return '';
+    if ((0, ast_1.isNode)(node, 'Identifier'))
+        return (0, ast_1.getName)(node);
+    if ((0, ast_1.isNode)(node, 'IndexAccess'))
+        return assignmentRootName(node.base || node.baseExpression);
+    if ((0, ast_1.isNode)(node, 'MemberAccess'))
+        return assignmentRootName(node.expression) || String(node.memberName || '');
+    return '';
+}
+function getStatements(body) {
+    if (!body || typeof body !== 'object')
+        return [];
+    return Array.isArray(body.statements) ? body.statements : [];
+}
+function getModifierName(modifier) {
+    if (!modifier)
+        return '';
+    if (typeof modifier === 'string')
+        return modifier;
+    if (typeof modifier.name === 'string')
+        return modifier.name;
+    if (modifier.name && typeof modifier.name.name === 'string')
+        return modifier.name.name;
+    if (modifier.modifierName && typeof modifier.modifierName.name === 'string')
+        return modifier.modifierName.name;
+    return '';
+}
+function getCalleeName(expr) {
+    if (!expr)
+        return '';
+    if ((0, ast_1.isNode)(expr, 'Identifier'))
+        return (0, ast_1.getName)(expr);
+    if ((0, ast_1.isNode)(expr, 'MemberAccess'))
+        return String(expr.memberName || '');
+    return '';
+}
+function containsNode(root, target) {
+    return Boolean(findFirst(root, node => node === target));
+}
+function findFirst(node, predicate) {
+    if (!node || typeof node !== 'object')
+        return null;
+    if (predicate(node))
+        return node;
+    for (const child of childrenOf(node)) {
+        const found = findFirst(child, predicate);
+        if (found)
+            return found;
+    }
+    return null;
+}
+function childrenOf(node) {
+    if (!node || typeof node !== 'object')
+        return [];
+    const out = [];
+    for (const [key, value] of Object.entries(node)) {
+        if (key === 'loc' || key === 'range' || key === 'src')
+            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;
+}
+//# sourceMappingURL=dn404-mirror-access-control.js.map

package/dist/detectors/doge-flashloan.d.ts

@@ -0,0 +1,29 @@
+import type { ScanResult } from '../index';
+export declare class DogeFlashloanDetector {
+    readonly id = "doge-flashloan";
+    readonly patternKey = "doge-flashloan";
+    readonly supportedAstKinds: ("parser" | "solc")[];
+    readonly descriptor: {
+        id: string;
+        shortDescription: string;
+        helpUri: string;
+        defaultSeverity: "high";
+        help: string;
+    };
+    private currentFile;
+    private lineOffsets;
+    private findings;
+    private currentContract;
+    private fn;
+    setFile(file: string): void;
+    setSourceText(sourceText?: string): void;
+    getFindings(): ScanResult[];
+    ContractDefinition(node: any): void;
+    ContractDefinition_post(_node: any): void;
+    ['ContractDefinition:exit'](node: any): void;
+    FunctionDefinition(node: any): void;
+    FunctionDefinition_post(_node: any): void;
+    ['FunctionDefinition:exit'](node: any): void;
+    FunctionCall(node: any): void;
+    private makeFinding;
+}