@snovon/solast 0.2.0

package/dist/detectors/arbitrary-recipient-no-access-control.js

@@ -0,0 +1,638 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArbitraryRecipientNoAccessControlDetector = void 0;
+const RULE_ID = 'arbitrary-recipient-no-access-control';
+const ACCESS_CONTROL_MODIFIERS = new Set([
+    'onlyowner',
+    'onlyrole',
+    'onlyadmin',
+    'onlybridge',
+    'onlymessenger',
+    'onlyoperator',
+    'onlygovernance',
+    'onlygovernor',
+    'onlyguardian',
+    'onlymanager',
+    'onlyauthorized',
+]);
+const PRIVILEGED_AUTHORITY_PATTERN = /owner|admin|role|bridge|messenger|portal|gateway|guardian|governor|governance|operator|manager|authorized|authority/i;
+class ArbitraryRecipientNoAccessControlDetector {
+    id = RULE_ID;
+    patternKey = RULE_ID;
+    supportedAstKinds = ['parser'];
+    scanAst(ast, file, sourceText) {
+        if (!ast || typeof ast !== 'object')
+            return [];
+        const findings = [];
+        const lineOffsets = buildLineOffsets(sourceText);
+        for (const contractNode of collectContracts(ast)) {
+            if (isInterfaceLike(contractNode))
+                continue;
+            const contractName = getName(contractNode) || '<anonymous>';
+            const modifierBodies = collectModifierBodies(contractNode);
+            for (const fn of getContractFunctions(contractNode)) {
+                if (!isExternallyCallable(fn))
+                    continue;
+                if (hasRecognizedAccessControlModifier(fn, modifierBodies))
+                    continue;
+                if (hasRecognizedInlineAccessControlGuard(fn))
+                    continue;
+                const params = getFunctionParameters(fn).filter(isPlainAddressParameter);
+                if (params.length === 0)
+                    continue;
+                const paramNames = new Set(params.map(p => getName(p)).filter(Boolean));
+                const aliasMap = collectAliases(getFunctionBody(fn));
+                const callerBindings = collectCallerBindings(getFunctionBody(fn));
+                const sinks = collectSinks(getFunctionBody(fn), paramNames, aliasMap);
+                const unsafe = sinks.find(sink => !isBoundToCaller(sink.paramName, aliasMap, callerBindings));
+                if (!unsafe)
+                    continue;
+                const fnName = functionDisplayName(fn);
+                const loc = getLoc(unsafe.node, lineOffsets) || getLoc(fn, lineOffsets) || { line: 0, column: 0 };
+                findings.push({
+                    file,
+                    contract: contractName,
+                    'function': fnName,
+                    line: loc.line,
+                    endLine: loc.line,
+                    column: loc.column,
+                    pattern: RULE_ID,
+                    confidence: 'high',
+                    ruleId: RULE_ID,
+                    severity: 'high',
+                    message: `Arbitrary-recipient arbitrary recipient flow in '${contractName}.${fnName}': address parameter '${unsafe.paramName}' reaches ${unsafe.sinkName} without being bound to msg.sender or protected by access control.`,
+                    rationale: 'Matches the arbitrary-recipient class where a public bridge/finalization-style entry point lets any caller choose the recipient of token or ETH movement without a caller-recipient equality check or trusted-bridge/owner guard.',
+                    suggestedFix: `Bind '${unsafe.paramName}' to msg.sender before the transfer sink, or restrict the entry point with an explicit bridge/owner/role access-control guard.`,
+                    contractName,
+                    functionName: fnName,
+                    sourceLocation: loc,
+                    findingId: '',
+                    contractHash: '',
+                    source: 'x-20220608-optimism-arbitrary-recipient-no-access-control',
+                });
+            }
+        }
+        return findings;
+    }
+}
+exports.ArbitraryRecipientNoAccessControlDetector = ArbitraryRecipientNoAccessControlDetector;
+function collectSinks(body, paramNames, aliasMap) {
+    const out = [];
+    walk(body, node => {
+        if (!isNode(node, 'FunctionCall'))
+            return;
+        const sink = sinkArgument(node);
+        if (!sink)
+            return;
+        const paramName = paramFlowName(sink.arg, paramNames, aliasMap);
+        if (paramName && sink.amountArg && amountDerivedFromRecipient(sink.amountArg, paramName, aliasMap))
+            return;
+        if (paramName)
+            out.push({ node, paramName, sinkName: sink.name });
+    });
+    return out;
+}
+function sinkArgument(node) {
+    const memberName = getCallMemberName(node).toLowerCase();
+    const args = getCallArguments(node);
+    if ((memberName === 'transfer' || memberName === 'safetransfer') && args[0]) {
+        return { name: memberName, arg: args[0] };
+    }
+    if ((memberName === 'transferfrom' || memberName === 'safetransferfrom') && args[1]) {
+        return { name: memberName, arg: args[1] };
+    }
+    if (memberName === 'call' && callHasValueOption(node)) {
+        const receiver = getCallReceiver(node);
+        const amountArg = getValueOptionArgument(node);
+        if (receiver)
+            return { name: 'call{value: ...}', arg: receiver, amountArg };
+    }
+    return null;
+}
+function paramFlowName(node, paramNames, aliasMap) {
+    if (!node || typeof node !== 'object')
+        return null;
+    if (isNode(node, 'Identifier')) {
+        const name = getName(node);
+        if (paramNames.has(name))
+            return name;
+        const alias = aliasMap.get(name);
+        return alias ? paramFlowName(alias, paramNames, aliasMap) : null;
+    }
+    if (isPayableCast(node)) {
+        return paramFlowName(getCallArguments(node)[0], paramNames, aliasMap);
+    }
+    return null;
+}
+function collectAliases(body) {
+    const map = new Map();
+    walk(body, node => {
+        if (!isNode(node, 'VariableDeclarationStatement'))
+            return;
+        const init = node.initialValue ?? node.initialExpression ?? node.expression;
+        if (!init)
+            return;
+        const declarations = node.variables ?? node.declarations;
+        if (!Array.isArray(declarations) || declarations.length !== 1)
+            return;
+        const declName = getName(declarations[0]);
+        if (declName)
+            map.set(declName, init);
+    });
+    return map;
+}
+function amountDerivedFromRecipient(amount, paramName, aliasMap) {
+    const resolved = resolveAlias(amount, aliasMap, new Set());
+    let found = false;
+    walk(resolved, node => {
+        if (found || !isNode(node, 'IndexAccess'))
+            return;
+        const index = node.indexExpression || node.index;
+        if (isIdentifierNamed(index, paramName))
+            found = true;
+    });
+    return found;
+}
+function collectCallerBindings(body) {
+    const out = [];
+    for (const stmt of getBlockStatements(body)) {
+        if (isNode(stmt, 'ExpressionStatement')) {
+            const expr = stmt.expression;
+            if (isNode(expr, 'FunctionCall') && isRequireOrAssert(expr)) {
+                addEqualToMsgSender(getCallArguments(expr)[0], out);
+            }
+        }
+        if (isNode(stmt, 'IfStatement')) {
+            const trueBody = stmt.trueBody || stmt.body;
+            if (bodyUnconditionallyExits(trueBody)) {
+                addNotEqualToMsgSender(stmt.condition, out);
+            }
+        }
+    }
+    return out;
+}
+function isBoundToCaller(paramName, aliasMap, bindings) {
+    for (const expr of bindings) {
+        const resolved = resolveAlias(expr, aliasMap, new Set());
+        if (isIdentifierNamed(resolved, paramName))
+            return true;
+    }
+    return false;
+}
+function addEqualToMsgSender(node, out) {
+    if (!node || typeof node !== 'object')
+        return;
+    if (!isNode(node, 'BinaryOperation'))
+        return;
+    const op = String(node.operator || '');
+    const left = getLeft(node);
+    const right = getRight(node);
+    if (op === '&&') {
+        addEqualToMsgSender(left, out);
+        addEqualToMsgSender(right, out);
+        return;
+    }
+    if (op === '==' || op === '===') {
+        if (isMsgSender(left) && right)
+            out.push(right);
+        if (isMsgSender(right) && left)
+            out.push(left);
+    }
+}
+function addNotEqualToMsgSender(node, out) {
+    if (!node || typeof node !== 'object')
+        return;
+    if (!isNode(node, 'BinaryOperation'))
+        return;
+    const op = String(node.operator || '');
+    const left = getLeft(node);
+    const right = getRight(node);
+    if (op === '||') {
+        addNotEqualToMsgSender(left, out);
+        addNotEqualToMsgSender(right, out);
+        return;
+    }
+    if (op === '!=' || op === '!==') {
+        if (isMsgSender(left) && right)
+            out.push(right);
+        if (isMsgSender(right) && left)
+            out.push(left);
+    }
+}
+function resolveAlias(node, aliasMap, visited) {
+    if (!node || typeof node !== 'object')
+        return node;
+    if (isNode(node, 'Identifier')) {
+        const name = getName(node);
+        if (name && aliasMap.has(name) && !visited.has(name)) {
+            const next = new Set(visited);
+            next.add(name);
+            return resolveAlias(aliasMap.get(name), aliasMap, next);
+        }
+    }
+    return node;
+}
+function hasRecognizedAccessControlModifier(fn, modifierBodies) {
+    for (const modifier of fn.modifiers || []) {
+        const modName = getModifierName(modifier);
+        if (ACCESS_CONTROL_MODIFIERS.has(modName.toLowerCase()))
+            return true;
+        const body = modifierBodies.get(modName);
+        if (body && bodyContainsAccessControlGuard(body))
+            return true;
+    }
+    return false;
+}
+function hasRecognizedInlineAccessControlGuard(fn) {
+    for (const stmt of getBlockStatements(getFunctionBody(fn))) {
+        if (isRecognizedAccessControlGuardStatement(stmt))
+            return true;
+        if (isMeaningfulActionStatement(stmt))
+            return false;
+    }
+    return false;
+}
+function bodyContainsAccessControlGuard(body) {
+    let found = false;
+    walk(body, node => {
+        if (!found && isRecognizedAccessControlGuardExpression(node))
+            found = true;
+    });
+    return found;
+}
+function isRecognizedAccessControlGuardStatement(stmt) {
+    if (!stmt || typeof stmt !== 'object')
+        return false;
+    if (isNode(stmt, 'ExpressionStatement'))
+        return isRecognizedAccessControlGuardExpression(stmt.expression);
+    if (isNode(stmt, 'IfStatement')) {
+        const trueBody = stmt.trueBody || stmt.body;
+        return bodyUnconditionallyExits(trueBody) && isInverseAccessControlCondition(stmt.condition);
+    }
+    return false;
+}
+function isRecognizedAccessControlGuardExpression(expr) {
+    if (!isNode(expr, 'FunctionCall'))
+        return false;
+    const callee = getCalleeName(expr).toLowerCase();
+    const args = getCallArguments(expr);
+    if (callee === 'require' || callee === 'assert') {
+        return args.some(arg => isPrivilegedSenderEquality(arg) || isHasRoleSenderCall(arg));
+    }
+    return (callee === '_checkrole' || callee === 'checkrole') && args.some(isMsgSender);
+}
+function isPrivilegedSenderEquality(expr) {
+    if (!isNode(expr, 'BinaryOperation'))
+        return false;
+    const op = String(expr.operator || '');
+    if (op === '&&')
+        return isPrivilegedSenderEquality(getLeft(expr)) || isPrivilegedSenderEquality(getRight(expr));
+    if (op !== '==' && op !== '===')
+        return false;
+    const left = getLeft(expr);
+    const right = getRight(expr);
+    return (isMsgSender(left) && isPrivilegedAuthorityReference(right)) ||
+        (isMsgSender(right) && isPrivilegedAuthorityReference(left));
+}
+function isInverseAccessControlCondition(cond) {
+    if (isNode(cond, 'UnaryOperation') && String(cond.operator || '') === '!') {
+        return isHasRoleSenderCall(cond.subExpression ?? cond.argument);
+    }
+    if (!isNode(cond, 'BinaryOperation'))
+        return false;
+    const op = String(cond.operator || '');
+    if (op === '||')
+        return isInverseAccessControlCondition(getLeft(cond)) || isInverseAccessControlCondition(getRight(cond));
+    if (op !== '!=' && op !== '!==')
+        return false;
+    const left = getLeft(cond);
+    const right = getRight(cond);
+    return (isMsgSender(left) && isPrivilegedAuthorityReference(right)) ||
+        (isMsgSender(right) && isPrivilegedAuthorityReference(left));
+}
+function isPrivilegedAuthorityReference(expr) {
+    if (!expr || typeof expr !== 'object')
+        return false;
+    if (isNode(expr, 'Identifier'))
+        return PRIVILEGED_AUTHORITY_PATTERN.test(getName(expr));
+    if (isNode(expr, 'MemberAccess')) {
+        return PRIVILEGED_AUTHORITY_PATTERN.test(String(expr.memberName || '')) ||
+            isPrivilegedAuthorityReference(expr.expression);
+    }
+    if (isNode(expr, 'FunctionCall')) {
+        return PRIVILEGED_AUTHORITY_PATTERN.test(getCalleeName(expr)) ||
+            isPrivilegedAuthorityReference(expr.expression);
+    }
+    return false;
+}
+function isHasRoleSenderCall(expr) {
+    if (!isNode(expr, 'FunctionCall'))
+        return false;
+    return getCalleeName(expr).toLowerCase() === 'hasrole' && getCallArguments(expr).some(isMsgSender);
+}
+function isMeaningfulActionStatement(stmt) {
+    if (!stmt || typeof stmt !== 'object')
+        return false;
+    if (isNode(stmt, 'VariableDeclarationStatement') || isNode(stmt, 'EmitStatement'))
+        return false;
+    if (isNode(stmt, 'ExpressionStatement')) {
+        const expr = stmt.expression;
+        if (isNode(expr, 'FunctionCall') && isRequireOrAssert(expr))
+            return false;
+        return true;
+    }
+    return true;
+}
+function isPlainAddressParameter(param) {
+    const typeName = typeNameToString(param?.typeName).toLowerCase();
+    return typeName === 'address' || typeName === 'address payable';
+}
+function typeNameToString(typeName) {
+    if (!typeName)
+        return '';
+    if (typeof typeName === 'string')
+        return typeName;
+    if (isNode(typeName, 'ElementaryTypeName'))
+        return String(typeName.name || '');
+    if (typeName.baseTypeName)
+        return typeNameToString(typeName.baseTypeName);
+    if (typeof typeName.name === 'string')
+        return typeName.name;
+    if (typeof typeName.namePath === 'string')
+        return typeName.namePath;
+    return '';
+}
+function callHasValueOption(node) {
+    const optionArgs = node?.expression?.arguments;
+    if (isNode(optionArgs, 'NameValueList') && Array.isArray(optionArgs.names)) {
+        return optionArgs.names.map(String).includes('value');
+    }
+    const names = [
+        ...(Array.isArray(node?.names) ? node.names : []),
+        ...(Array.isArray(node?.optionNames) ? node.optionNames : []),
+    ].map(String);
+    if (names.includes('value'))
+        return true;
+    let found = false;
+    walk(node.expression, child => {
+        if (found)
+            return;
+        if (isNode(child, 'NameValueExpression') && String(child.name || child.keyName || '') === 'value')
+            found = true;
+        if (isNode(child, 'FunctionCallOptions')) {
+            const optionNames = child.names || child.optionNames || [];
+            if (Array.isArray(optionNames) && optionNames.map(String).includes('value'))
+                found = true;
+        }
+    });
+    return found;
+}
+function getValueOptionArgument(node) {
+    const optionArgs = node?.expression?.arguments;
+    if (isNode(optionArgs, 'NameValueList') && Array.isArray(optionArgs.names) && Array.isArray(optionArgs.arguments)) {
+        const index = optionArgs.names.map(String).indexOf('value');
+        return index >= 0 ? optionArgs.arguments[index] : null;
+    }
+    return null;
+}
+function getCallReceiver(node) {
+    const expr = unwrapNameValueExpression(node?.expression);
+    if (!isNode(expr, 'MemberAccess'))
+        return null;
+    return expr.expression || null;
+}
+function isPayableCast(node) {
+    if (!isNode(node, 'FunctionCall'))
+        return false;
+    const expr = node.expression;
+    if (isNode(expr, 'Identifier') && getName(expr) === 'payable')
+        return true;
+    if (isNode(expr, 'ElementaryTypeNameExpression')) {
+        const typeName = expr.typeName;
+        return String(typeName?.name || typeName || '') === 'payable';
+    }
+    return false;
+}
+function isRequireOrAssert(call) {
+    const name = getCalleeName(call).toLowerCase();
+    return name === 'require' || name === 'assert';
+}
+function bodyUnconditionallyExits(body) {
+    if (!body || typeof body !== 'object')
+        return false;
+    if (isNode(body, 'Block'))
+        return getBlockStatements(body).some(statementGuaranteesExit);
+    return statementGuaranteesExit(body);
+}
+function statementGuaranteesExit(stmt) {
+    if (!stmt || typeof stmt !== 'object')
+        return false;
+    if (isNode(stmt, 'ThrowStatement') || isNode(stmt, 'RevertStatement'))
+        return true;
+    if (isNode(stmt, 'ExpressionStatement')) {
+        const expr = stmt.expression;
+        return isNode(expr, 'FunctionCall') && getCalleeName(expr).toLowerCase() === 'revert';
+    }
+    if (isNode(stmt, 'Block'))
+        return bodyUnconditionallyExits(stmt);
+    return false;
+}
+function collectModifierBodies(contractNode) {
+    const map = new Map();
+    for (const member of getContractMembers(contractNode)) {
+        if (!isNode(member, 'ModifierDefinition'))
+            continue;
+        const name = getName(member);
+        if (name && member.body)
+            map.set(name, member.body);
+    }
+    return map;
+}
+function collectContracts(ast) {
+    const out = [];
+    walkContracts(ast, node => out.push(node));
+    return out;
+}
+function walkContracts(node, visit) {
+    if (!node || typeof node !== 'object')
+        return;
+    if (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 children = [];
+    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')
+                    children.push(item);
+            }
+        }
+        else if (value && typeof value === 'object') {
+            children.push(value);
+        }
+    }
+    return children;
+}
+function isInterfaceLike(contractNode) {
+    const kind = String(contractNode?.kind || contractNode?.contractKind || '').toLowerCase();
+    return kind === 'interface' || kind === 'library';
+}
+function isExternallyCallable(fn) {
+    if (!fn || !getFunctionBody(fn) || isConstructor(fn))
+        return false;
+    const visibility = String(fn.visibility || '').toLowerCase();
+    return visibility === 'public' || visibility === 'external';
+}
+function isConstructor(fn) {
+    return fn?.isConstructor === true || String(fn?.kind || '').toLowerCase() === 'constructor';
+}
+function getContractFunctions(contractNode) {
+    return getContractMembers(contractNode).filter(child => isNode(child, 'FunctionDefinition'));
+}
+function getContractMembers(contractNode) {
+    if (!contractNode || typeof contractNode !== 'object')
+        return [];
+    if (Array.isArray(contractNode.subNodes))
+        return contractNode.subNodes;
+    if (Array.isArray(contractNode.nodes))
+        return contractNode.nodes;
+    return [];
+}
+function getFunctionBody(node) {
+    return node?.body || null;
+}
+function getFunctionParameters(fn) {
+    const params = fn?.parameters;
+    if (Array.isArray(params))
+        return params;
+    if (Array.isArray(params?.parameters))
+        return params.parameters;
+    return [];
+}
+function getBlockStatements(body) {
+    if (!body || typeof body !== 'object')
+        return [];
+    return Array.isArray(body.statements) ? body.statements : [];
+}
+function getCallArguments(node) {
+    return Array.isArray(node?.arguments) ? node.arguments : [];
+}
+function getCallMemberName(node) {
+    const expr = unwrapNameValueExpression(node?.expression);
+    if (isNode(expr, 'MemberAccess'))
+        return String(expr.memberName || '');
+    return '';
+}
+function getCalleeName(node) {
+    const expr = node?.expression;
+    if (isNode(expr, 'Identifier'))
+        return String(expr.name || '');
+    if (isNode(expr, 'MemberAccess'))
+        return String(expr.memberName || '');
+    return '';
+}
+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 === 'object') {
+        if (typeof modifier.name.name === 'string')
+            return modifier.name.name;
+        if (typeof modifier.name.namePath === 'string')
+            return modifier.name.namePath;
+    }
+    if (modifier.modifierName) {
+        const inner = modifier.modifierName;
+        if (typeof inner === 'string')
+            return inner;
+        if (typeof inner.name === 'string')
+            return inner.name;
+    }
+    return '';
+}
+function getName(node) {
+    return typeof node?.name === 'string' ? node.name : '';
+}
+function functionDisplayName(fn) {
+    return getName(fn) || '<anonymous>';
+}
+function getLeft(node) {
+    return node?.left ?? node?.leftExpression ?? node?.leftHandSide;
+}
+function getRight(node) {
+    return node?.right ?? node?.rightExpression ?? node?.rightHandSide;
+}
+function isIdentifierNamed(node, name) {
+    return isNode(node, 'Identifier') && getName(node) === name;
+}
+function isMsgSender(node) {
+    if (isNode(node, 'MemberAccess') &&
+        String(node.memberName || '') === 'sender' &&
+        isNode(node.expression, 'Identifier') &&
+        getName(node.expression) === 'msg')
+        return true;
+    if (isNode(node, 'FunctionCall')) {
+        const callee = node.expression;
+        return isNode(callee, 'Identifier') && getName(callee) === '_msgSender' && getCallArguments(node).length === 0;
+    }
+    return false;
+}
+function isNode(node, kind) {
+    return node?.type === kind || node?.nodeType === kind;
+}
+function unwrapNameValueExpression(node) {
+    if (isNode(node, 'NameValueExpression'))
+        return node.expression;
+    if (isNode(node, 'FunctionCallOptions'))
+        return node.expression;
+    return node;
+}
+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] };
+}
+//# sourceMappingURL=arbitrary-recipient-no-access-control.js.map

package/dist/detectors/arbitrary-storage-proof-forgery.d.ts

@@ -0,0 +1,35 @@
+import type { ScanResult } from '../index';
+export declare class ArbitraryStorageProofForgeryDetector {
+    readonly id = "arbitrary-storage-proof-forgery";
+    readonly patternKey = "arbitrary-storage-proof-forgery";
+    readonly descriptor: {
+        id: string;
+        shortDescription: string;
+        helpUri: string;
+        defaultSeverity: "high";
+    };
+    readonly supportedAstKinds: "parser"[];
+    private findings;
+    private currentContract;
+    private currentContractKind;
+    private stateVars;
+    private functionStack;
+    setFile(_file: string): void;
+    getFindings(): ScanResult[];
+    ContractDefinition(node: any): void;
+    'ContractDefinition:exit'(): void;
+    FunctionDefinition(node: any): void;
+    'FunctionDefinition:exit'(node: any): void;
+    VariableDeclarationStatement(node: any): void;
+    FunctionCall(node: any): void;
+    IfStatement(node: any): void;
+    private currentFunction;
+    private analyzeFunction;
+    private findDecodedStructName;
+    private expandLocalCoverage;
+    private collectChecks;
+    private captureDecodedField;
+    private decodeChecksAreIncomplete;
+    private directProofChecksAreIncomplete;
+    private isTrustedOrBound;
+}