@snovon/solast 0.2.0

package/dist/detectors/cross-chain-intent-stale-resolution.js

@@ -0,0 +1,463 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrossChainIntentStaleResolutionDetector = void 0;
+const ast_1 = require("./_common/ast");
+const RULE_ID = 'cross-chain-intent-stale-resolution';
+const PATTERN_DEADLINE = `${RULE_ID}/missing-deadline-check`;
+const PATTERN_LIQUIDITY = `${RULE_ID}/missing-liquidity-check`;
+const INTENT_TYPE_NAMES = new Set([
+    'OrderData', 'ResolvedCrossChainOrder', 'GaslessCrossChainOrder',
+    'OnchainCrossChainOrder', 'CrossChainOrder', 'Order', 'FillInstruction',
+]);
+const DEADLINE_NAME_RE = /^(?:.*deadline|deadline.*|.*expiry|expiry.*|expires?|expiration|validuntil|ttl|timeout)$/i;
+const PARAM_AMOUNT_RE = /^(fillamount|fill_amount|amount|output|minout|minamount)$/i;
+const PARAM_PRICE_RE = /^(price|rate|executionprice|quotedprice)$/i;
+function looksLikeDeadlineName(name) {
+    return DEADLINE_NAME_RE.test(name);
+}
+const TRANSFER_MEMBERS = new Set([
+    'transfer', 'send', 'transferfrom', 'safetransfer', 'safetransferfrom',
+    'transferout',
+]);
+const BALANCE_MEMBERS = new Set([
+    'balanceof', 'getbalance', 'balance', 'totalsupply',
+]);
+class CrossChainIntentStaleResolutionDetector {
+    id = RULE_ID;
+    patternKey = RULE_ID;
+    supportedAstKinds = ['parser'];
+    scanAst(ast, file) {
+        if (!ast || ast.type !== 'SourceUnit')
+            return [];
+        const findings = [];
+        const structInfo = collectStructInfo(ast);
+        for (const contract of ast.children || []) {
+            if (contract?.type !== 'ContractDefinition')
+                continue;
+            if (contract.kind === 'interface' || contract.kind === 'library')
+                continue;
+            for (const fn of contract.subNodes || []) {
+                if (fn?.type !== 'FunctionDefinition')
+                    continue;
+                if (!fn.body)
+                    continue;
+                if (fn.isConstructor || fn.kind === 'constructor')
+                    continue;
+                const result = analyzeFn(fn, structInfo);
+                if (!result)
+                    continue;
+                const contractName = String(contract.name || '<anon>');
+                const fnName = String(fn.name || '<anon>');
+                findings.push(makeFinding(file, contractName, fnName, result.loc, result.pattern));
+            }
+        }
+        return findings;
+    }
+}
+exports.CrossChainIntentStaleResolutionDetector = CrossChainIntentStaleResolutionDetector;
+function collectStructInfo(ast) {
+    const map = new Map();
+    const visit = (node) => {
+        if (!node || typeof node !== 'object')
+            return;
+        if (node.type === 'StructDefinition' && node.name) {
+            const info = { hasDeadline: false, hasAmountOrPrice: false };
+            for (const m of node.members || []) {
+                const mname = String(m?.name || '');
+                if (looksLikeDeadlineName(mname))
+                    info.hasDeadline = true;
+                if (PARAM_AMOUNT_RE.test(mname) || PARAM_PRICE_RE.test(mname))
+                    info.hasAmountOrPrice = true;
+            }
+            map.set(node.name, info);
+        }
+        for (const child of children(node))
+            visit(child);
+    };
+    for (const child of ast.children || [])
+        visit(child);
+    return map;
+}
+function analyzeFn(fn, structs) {
+    let deadlineEligible = false;
+    let amountEligible = false;
+    for (const p of fn.parameters || []) {
+        const pname = String(p?.name || '');
+        if (looksLikeDeadlineName(pname))
+            deadlineEligible = true;
+        if (PARAM_AMOUNT_RE.test(pname) || PARAM_PRICE_RE.test(pname))
+            amountEligible = true;
+        const tname = userTypeName(p?.typeName);
+        if (tname) {
+            if (INTENT_TYPE_NAMES.has(tname)) {
+                deadlineEligible = true;
+                amountEligible = true;
+            }
+            const info = structs.get(tname);
+            if (info) {
+                if (info.hasDeadline)
+                    deadlineEligible = true;
+                if (info.hasAmountOrPrice)
+                    amountEligible = true;
+            }
+        }
+    }
+    collectBodySignals(fn.body, structs, signal => {
+        if (signal === 'deadline')
+            deadlineEligible = true;
+        if (signal === 'amount')
+            amountEligible = true;
+    });
+    if (!deadlineEligible || !amountEligible)
+        return null;
+    const state = {
+        deadlineEligible,
+        amountEligible,
+        sawDeadlineGuard: false,
+        sawLiquidityGuard: false,
+        finding: null,
+    };
+    walkBody(fn.body, state);
+    if (state.finding) {
+        return { pattern: state.finding.pattern, loc: state.finding.loc };
+    }
+    return null;
+}
+function collectBodySignals(node, structs, emit) {
+    if (!node || typeof node !== 'object')
+        return;
+    if (node.type === 'VariableDeclarationStatement') {
+        for (const v of node.variables || []) {
+            if (!v)
+                continue;
+            const vname = String(v.name || '');
+            if (looksLikeDeadlineName(vname))
+                emit('deadline');
+            if (PARAM_AMOUNT_RE.test(vname) || PARAM_PRICE_RE.test(vname))
+                emit('amount');
+            const tname = userTypeName(v.typeName);
+            if (tname) {
+                if (INTENT_TYPE_NAMES.has(tname)) {
+                    emit('deadline');
+                    emit('amount');
+                }
+                const info = structs.get(tname);
+                if (info) {
+                    if (info.hasDeadline)
+                        emit('deadline');
+                    if (info.hasAmountOrPrice)
+                        emit('amount');
+                }
+            }
+        }
+    }
+    if (node.type === 'MemberAccess') {
+        const m = String(node.memberName || '');
+        if (looksLikeDeadlineName(m))
+            emit('deadline');
+        if (PARAM_AMOUNT_RE.test(m) || PARAM_PRICE_RE.test(m))
+            emit('amount');
+    }
+    for (const child of children(node))
+        collectBodySignals(child, structs, emit);
+}
+function walkBody(node, state) {
+    if (!node || typeof node !== 'object')
+        return;
+    if (state.finding)
+        return;
+    if (node.type === 'Block') {
+        for (const stmt of node.statements || []) {
+            walkBody(stmt, state);
+            if (state.finding)
+                return;
+        }
+        return;
+    }
+    if (node.type === 'IfStatement') {
+        if (isRevertBody(node.trueBody)) {
+            const condHasSink = containsTransferSink(node.condition);
+            if (!condHasSink) {
+                detectGuards(node.condition, state);
+            }
+        }
+        walkBody(node.condition, state);
+        if (state.finding)
+            return;
+        walkBody(node.trueBody, state);
+        if (state.finding)
+            return;
+        walkBody(node.falseBody, state);
+        return;
+    }
+    if (node.type === 'VariableDeclarationStatement') {
+        if (node.initialValue)
+            walkBody(node.initialValue, state);
+        return;
+    }
+    if (node.type === 'ExpressionStatement') {
+        walkBody(node.expression, state);
+        return;
+    }
+    if (node.type === 'FunctionCall') {
+        const callee = unwrapCallee(node.expression);
+        const directName = identifierName(callee).toLowerCase();
+        if (directName === 'require' || directName === 'assert') {
+            const args = node.arguments || [];
+            const cond = args[0];
+            if (cond) {
+                const condHasSink = containsTransferSink(cond);
+                if (!condHasSink) {
+                    detectGuards(cond, state);
+                }
+                walkBody(cond, state);
+            }
+            for (let i = 1; i < args.length; i++)
+                walkBody(args[i], state);
+            return;
+        }
+        if (isTransferSinkCallee(callee)) {
+            recordSinkFinding(node, state);
+            return;
+        }
+        for (const arg of node.arguments || [])
+            walkBody(arg, state);
+        return;
+    }
+    for (const child of children(node)) {
+        walkBody(child, state);
+        if (state.finding)
+            return;
+    }
+}
+function recordSinkFinding(node, state) {
+    if (state.finding)
+        return;
+    if (state.deadlineEligible && !state.sawDeadlineGuard) {
+        state.finding = { pattern: PATTERN_DEADLINE, loc: locOf(node) };
+        return;
+    }
+    if (state.amountEligible && !state.sawLiquidityGuard) {
+        state.finding = { pattern: PATTERN_LIQUIDITY, loc: locOf(node) };
+        return;
+    }
+}
+function detectGuards(node, state) {
+    if (!node || typeof node !== 'object')
+        return;
+    if (node.type === 'BinaryOperation') {
+        const op = String(node.operator || '');
+        if (['<=', '>=', '<', '>', '==', '!='].includes(op)) {
+            const l = unwrapExpr(node.left);
+            const r = unwrapExpr(node.right);
+            if ((isBlockTimestamp(l) && isDeadlineLike(r)) || (isBlockTimestamp(r) && isDeadlineLike(l))) {
+                state.sawDeadlineGuard = true;
+            }
+            if (containsBalanceCall(l) || containsBalanceCall(r)) {
+                state.sawLiquidityGuard = true;
+            }
+        }
+    }
+    if (node.type === 'FunctionCall') {
+        const callee = unwrapCallee(node.expression);
+        if (callee?.type === 'MemberAccess') {
+            const m = String(callee.memberName || '').toLowerCase();
+            if (BALANCE_MEMBERS.has(m)) {
+                state.sawLiquidityGuard = true;
+            }
+            const baseName = identifierName(unwrapExpr(callee.expression));
+            if (baseName && !TRANSFER_MEMBERS.has(m) && m !== 'call' && !BALANCE_MEMBERS.has(m)) {
+                const argSignals = collectArgKeywordSignals(node.arguments);
+                if (argSignals.deadline)
+                    state.sawDeadlineGuard = true;
+                if (argSignals.amount)
+                    state.sawLiquidityGuard = true;
+            }
+        }
+    }
+    for (const child of children(node))
+        detectGuards(child, state);
+}
+function collectArgKeywordSignals(args) {
+    const out = { deadline: false, amount: false };
+    if (!Array.isArray(args))
+        return out;
+    const visit = (n) => {
+        if (!n || typeof n !== 'object')
+            return;
+        if (n.type === 'Identifier') {
+            const name = String(n.name || '');
+            if (looksLikeDeadlineName(name))
+                out.deadline = true;
+            if (PARAM_AMOUNT_RE.test(name) || PARAM_PRICE_RE.test(name))
+                out.amount = true;
+        }
+        if (n.type === 'MemberAccess') {
+            const m = String(n.memberName || '');
+            if (looksLikeDeadlineName(m))
+                out.deadline = true;
+            if (PARAM_AMOUNT_RE.test(m) || PARAM_PRICE_RE.test(m))
+                out.amount = true;
+        }
+        for (const c of children(n))
+            visit(c);
+    };
+    for (const a of args)
+        visit(a);
+    return out;
+}
+function isBlockTimestamp(n) {
+    if (!n || typeof n !== 'object')
+        return false;
+    if (n.type !== 'MemberAccess')
+        return false;
+    const base = unwrapExpr(n.expression);
+    return String(base?.name || '').toLowerCase() === 'block' &&
+        String(n.memberName || '').toLowerCase() === 'timestamp';
+}
+function isDeadlineLike(n) {
+    if (!n || typeof n !== 'object')
+        return false;
+    if (n.type === 'Identifier')
+        return looksLikeDeadlineName(String(n.name || ''));
+    if (n.type === 'MemberAccess')
+        return looksLikeDeadlineName(String(n.memberName || ''));
+    return false;
+}
+function containsBalanceCall(n) {
+    if (!n || typeof n !== 'object')
+        return false;
+    if (n.type === 'FunctionCall') {
+        const callee = unwrapCallee(n.expression);
+        if (callee?.type === 'MemberAccess' && BALANCE_MEMBERS.has(String(callee.memberName || '').toLowerCase())) {
+            return true;
+        }
+        if (callee?.type === 'Identifier' && BALANCE_MEMBERS.has(String(callee.name || '').toLowerCase())) {
+            return true;
+        }
+    }
+    if (n.type === 'MemberAccess') {
+        const m = String(n.memberName || '').toLowerCase();
+        if (m === 'balance' || m === 'totalsupply')
+            return true;
+    }
+    for (const child of children(n)) {
+        if (containsBalanceCall(child))
+            return true;
+    }
+    return false;
+}
+function containsTransferSink(n) {
+    if (!n || typeof n !== 'object')
+        return false;
+    if (n.type === 'FunctionCall') {
+        const callee = unwrapCallee(n.expression);
+        if (isTransferSinkCallee(callee))
+            return true;
+    }
+    for (const child of children(n)) {
+        if (containsTransferSink(child))
+            return true;
+    }
+    return false;
+}
+function isTransferSinkCallee(callee) {
+    if (!callee || typeof callee !== 'object')
+        return false;
+    if (callee.type !== 'MemberAccess')
+        return false;
+    const m = String(callee.memberName || '').toLowerCase();
+    if (TRANSFER_MEMBERS.has(m))
+        return true;
+    if (m === 'call')
+        return true;
+    return false;
+}
+function isRevertBody(node) {
+    if (!node || typeof node !== 'object')
+        return false;
+    if (node.type === 'RevertStatement')
+        return true;
+    if (node.type === 'Block' && Array.isArray(node.statements) && node.statements.length === 1) {
+        return isRevertBody(node.statements[0]);
+    }
+    return false;
+}
+function unwrapCallee(expr) {
+    let cur = expr;
+    while (cur && typeof cur === 'object' && (cur.type === 'NameValueExpression' || cur.type === 'FunctionCallOptions')) {
+        cur = cur.expression;
+    }
+    return cur;
+}
+function unwrapExpr(n) {
+    if (!n || typeof n !== 'object')
+        return n;
+    if (n.type === 'TupleExpression' && Array.isArray(n.components) && n.components.length === 1) {
+        return unwrapExpr(n.components[0]);
+    }
+    return n;
+}
+function identifierName(n) {
+    if (!n || typeof n !== 'object')
+        return '';
+    if (n.type === 'Identifier')
+        return String(n.name || '');
+    return '';
+}
+function userTypeName(typeName) {
+    if (!typeName || typeof typeName !== 'object')
+        return '';
+    if (typeName.type === 'UserDefinedTypeName') {
+        const np = String(typeName.namePath || typeName.name || '');
+        return np.split('.').pop() || '';
+    }
+    return '';
+}
+function children(node) {
+    const out = [];
+    if (!node || typeof node !== 'object')
+        return out;
+    for (const [key, val] of Object.entries(node)) {
+        if (key === 'loc' || key === 'range')
+            continue;
+        if (Array.isArray(val)) {
+            for (const item of val) {
+                if (item && typeof item === 'object' && item.type !== undefined)
+                    out.push(item);
+            }
+        }
+        else if (val && typeof val === 'object' && val.type !== undefined) {
+            out.push(val);
+        }
+    }
+    return out;
+}
+function locOf(node) {
+    const loc = (0, ast_1.tryLoc)(node) ?? { line: 1, endLine: 1, column: 0 };
+    return { line: loc.line, column: loc.column };
+}
+function makeFinding(file, contractName, functionName, loc, pattern) {
+    const message = pattern === PATTERN_DEADLINE
+        ? `Cross-chain intent resolver '${functionName}' reaches a fund-transferring sink without re-validating block.timestamp against an intent-derived deadline.`
+        : `Cross-chain intent resolver '${functionName}' reaches a fund-transferring sink without re-validating current liquidity/balance against the intent fill amount.`;
+    return {
+        file,
+        contract: contractName,
+        'function': functionName,
+        line: loc.line,
+        endLine: loc.line,
+        column: loc.column,
+        pattern,
+        confidence: 'high',
+        ruleId: RULE_ID,
+        severity: 'high',
+        message,
+        contractName,
+        functionName,
+        sourceLocation: { line: loc.line, column: loc.column },
+        findingId: '',
+        contractHash: '',
+    };
+}
+//# sourceMappingURL=cross-chain-intent-stale-resolution.js.map

package/dist/detectors/cross-chain-message-order-dependency.d.ts

@@ -0,0 +1,8 @@
+import type { ScanResult } from '../index';
+export declare class CrossChainMessageOrderDependencyDetector {
+    readonly id = "cross-chain-message-order-dependency";
+    readonly patternKey = "cross-chain-message-order-dependency";
+    readonly supportedAstKinds: "parser"[];
+    scan(ast: any, ctx?: any): ScanResult[];
+    scanAst(ast: any, file: string): ScanResult[];
+}