Struct CallerGuards 

struct CallerGuards<'gcx> {
    gcx: Gcx<'gcx>,
    alias_cache: HelperAnalysisCache<(VariableId, u8), bool>,
    stack: Vec<FunctionId>,
}

Recognises guards that restrict msg.sender to a deploy-time-fixed principal, backed by a memoised analysis of which state variables may alias address(this).

Fields

gcx: Gcx<'gcx>

alias_cache: HelperAnalysisCache<(VariableId, u8), bool>

stack: Vec<FunctionId>

Functions currently being inlined, to stop recursion.

Implementations

impl<'gcx> CallerGuards<'gcx>

fn new(gcx: Gcx<'gcx>) -> Self

fn modifier_restricts(&mut self, m: &Modifier<'_>) -> bool

True when modifier m reverts unless msg.sender is a trusted principal.

fn stmt_restricts(&mut self, stmt: &'gcx Stmt<'gcx>) -> bool

fn expr_restricts(&mut self, expr: &'gcx Expr<'gcx>) -> bool

require(guard) / assert(guard), or a call to an internal helper whose body restricts the caller and cannot return early.

fn cond_restricts(&mut self, cond: &'gcx Expr<'gcx>, holds: bool) -> bool

True when cond (holding iff holds) entails msg.sender == <trusted> on every path.

fn is_trusted_principal(&mut self, expr: &'gcx Expr<'gcx>, depth: u8) -> bool

Conservatively recognises deploy-time-fixed caller principals: address/zero literals and state (or statically indexed state) that cannot alias address(this), possibly behind a no-arg getter. Parameters, locals, msg.sender, tx.origin and this are rejected.

fn state_var_aliases_self(&mut self, v: VariableId, depth: u8) -> bool

True when state variable v may hold address(this): through its initializer or an assignment in any function of its contract or a derived contract.

fn rhs_carries_self( &mut self, target: &Variable<'_>, rhs: &'gcx Expr<'gcx>, depth: u8, locals: &HashSet<VariableId>, ) -> bool

Whether assigning rhs to target may plant address(this) in it: an address-typed target must receive address(this) itself, an aggregate may embed it anywhere.

fn expr_may_contain_self( &mut self, expr: &'gcx Expr<'gcx>, depth: u8, locals: &HashSet<VariableId>, ) -> bool

True when expr may embed address(this) (or a local carrying it) anywhere.

fn expr_resolves_to_self(&mut self, expr: &'gcx Expr<'gcx>, depth: u8) -> bool

True when expr may evaluate to address(this).

fn contract_assigns_self( &mut self, cid: ContractId, v: VariableId, depth: u8, ) -> bool

Scans every function of cid for an assignment that may plant address(this) in v.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 168 bytes