@snovon/solast 0.2.0

package/dist/detectors/arbitrary-call-error.d.ts

@@ -0,0 +1,127 @@
+import type { ScanResult } from '../index';
+type ArbitraryCallSeverity = 'warning' | 'high';
+export declare class ArbitraryCallErrorDetector {
+    readonly id: string;
+    readonly patternKey: string;
+    readonly supportedAstKinds: ("parser" | "solc")[];
+    private readonly outputSeverity;
+    private findings;
+    private currentFile;
+    private currentContract;
+    private currentFunction;
+    private currentFunctionGuarded;
+    private currentFunctionContextSuppressed;
+    private verifiedRequestIdentifiers;
+    private sawApproval;
+    private parameters;
+    private taintedLocals;
+    private localOrigins;
+    private selectorChecked;
+    private targetChecked;
+    private stateVariables;
+    private immutableStateVariables;
+    private seen;
+    private currentParameters;
+    private propagatedParamTaint;
+    private propagatedParamOrigins;
+    constructor(id?: string, severity?: ArbitraryCallSeverity);
+    setFile(file: string): void;
+    getFindings(): ScanResult[];
+    ContractDefinition(node: any): void;
+    ContractDefinition_post(_node: any): void;
+    StateVariableDeclaration(node: any): void;
+    FunctionDefinition(node: any): void;
+    FunctionDefinition_post(_node: any): void;
+    VariableDeclarationStatement(node: any): void;
+    ExpressionStatement(node: any): void;
+    IfStatement(node: any): void;
+    FunctionCall(node: any): void;
+    private inspectExpression;
+    private inspectLowLevelCall;
+    private inspectAddressFunctionCallWrapper;
+    private addFinding;
+    private lowLevelCall;
+    private addressFunctionCallWrapper;
+    private interfaceStyleCall;
+    private isDirectTaintedParameterTarget;
+    private isReadOnlyOracleAccessor;
+    private trackApproval;
+    private trackAssignment;
+    private trackInternalCallTaint;
+    private originForTaintedArgument;
+    private collectPropagatedParamTaint;
+    private summarizeFunctionTaint;
+    private containsSummaryTaint;
+    private walkExpression;
+    private trackValidationGate;
+    private markSelectorCompared;
+    private selectorDataName;
+    private isSelectorChecked;
+    private hasFixedSelectorCallData;
+    private markTargetValidated;
+    private isTargetChecked;
+    private isAbiDecodeOfTainted;
+    private containsTainted;
+    private containsTaintedIndexAccess;
+    private containsRangeAccess;
+    private isAaveRouteCall;
+    private isKelpOracleRoute;
+    private isOracleSensitiveCall;
+    private isOracleName;
+    private remediationFor;
+    private inputPathForOracle;
+    private inputPathFor;
+    private parameterSignature;
+    private typeNameToString;
+    private isMsgValue;
+    private isAddressThis;
+    private expressionToString;
+    private memberNameInChain;
+    private isEmptyCallData;
+    private hasAccessControl;
+    private looksLikeAccessControlName;
+    private hasSuppressedCallerContext;
+    private hasInternalOrPrivateVisibility;
+    private hasExternallyTaintedReachability;
+    private isExternallyCallable;
+    private containsAccessRequire;
+    /**
+     * Structural predicate — does the require argument express an access
+     * control check rather than a generic invariant? Recognized shapes:
+     *
+     *   require(msg.sender == owner)        BinaryOperation('==') with
+     *   require(admin == msg.sender)        msg.sender on one side and a
+     *                                       privilege-named storage ref on
+     *                                       the other.
+     *   require(_authorized[msg.sender])    IndexAccess base named for a
+     *                                       privilege concept, indexed by
+     *                                       msg.sender.
+     *   require(hasRole(role, msg.sender))  FunctionCall whose callee
+     *   require(_checkRole(role, ...))      tail name matches one of the
+     *                                       known role-check helpers.
+     *
+     * Recurses through &&/||/!/parentheses so multi-clause requires are
+     * recognized. The flattened-text fallback below is preserved for
+     * shapes the structural predicate doesn't yet recognize, which keeps
+     * recall stable while improving precision on the common cases —
+     * notably, `require(amount > 0 && callOwnerOf(msg.sender))` no longer
+     * matches just because both substrings appear somewhere.
+     */
+    private requireArgIsAccessControl;
+    private isMsgSenderExpr;
+    private isPrivilegedReference;
+    private collectVerifiedRequestIdentifiers;
+    private collectVerifyCallTargets;
+    private isMinimalForwarderCall;
+    private allTaintedRootsBoundTo;
+    private flattenNames;
+    private getCalleeName;
+    private getExpressionName;
+    private rootIdentifier;
+    private identifierName;
+    private nodeName;
+    private args;
+    private kind;
+    private forEachChild;
+}
+export {};