Flash Loan Interaction

FLASH_LOAN_INTERACTION Skill

Trigger Pattern: FLASH_LOAN flag (required) or BALANCE_DEPENDENT flag (optional complement) Inject Into: Breadth agents, depth-token-flow, depth-edge-case Purpose: Analyze flash loan attack surfaces in Aptos Move protocols, focusing on the hot potato receipt pattern, state manipulation during flash loan windows, and defense parity

For every flash-loan-accessible state variable or precondition in the protocol:

STEP PRIORITY: Steps 5 (Defense Audit) and 5b (Defense Parity) are where HIGH/CRITICAL severity findings most commonly hide. Do NOT rush these steps. If constrained, skip conditional sections (0c, 4) before skipping 5, 5b, or 3d.

0. External Flash Susceptibility Check

Before analyzing the protocol's OWN flash loan paths, check whether external protocols the contract interacts with are susceptible to third-party flash manipulation.

0a: External Interaction Inventory

0b: Third-Party Flash Attack Modeling

For each external state marked YES in 0a, model:

1. Before: Protocol reads external state X (e.g., pool reserves, spot price from AMM)
2. Flash manipulate: Attacker flash-borrows and trades on the external protocol to move state X
3. Victim call: Attacker calls OUR protocol function that reads manipulated state X
4. Restore: Attacker reverses the external manipulation
5. Impact: What did the attacker gain from our protocol acting on manipulated state?

Key question: Does our protocol use spot state (manipulable) or time-weighted state (resistant)?

0c: DEX Price Manipulation Cost Estimation

For each external DEX/pool whose spot state is read by the protocol, estimate manipulation cost:

For Aptos AMMs: Most use constant-product (xy=k) or stableswap curves. Identify the specific AMM type from the protocol's swap function signatures (weighted pools, stableswap, or standard xy=k).

1. Flash-Loan-Accessible State Inventory

Enumerate ALL protocol state that can be manipulated within a single transaction via flash-borrowed capital:

Aptos flash loan mechanics (hot potato pattern):

• Flash loan providers (Thala, Echelon, etc.) issue a FlashLoanReceipt struct with NO abilities (no copy, no drop, no store, no key)
• The receipt MUST be consumed by repay() in the same transaction -- Move's type system enforces this
• No callback mechanism: caller receives receipt, performs operations, then passes receipt to repay
• The receipt struct often contains the borrowed amount for repayment validation

For each YES entry: trace all functions that READ this state and make decisions based on it.

Rule 15 check: For each balance/oracle/threshold/rate precondition, model the flash loan atomic sequence.

2. Atomic Attack Sequence Modeling

For each flash-loan-accessible state identified in Step 1:

Attack Template

1. BORROW: Flash-borrow {amount} of {CoinType/FA} from {source}
   -> Receive FlashLoanReceipt (hot potato, no abilities)
2. MANIPULATE: {action} to change {state_variable} from {value_before} to {value_after}
3. CALL: Invoke {target_function} which reads manipulated state
4. EXTRACT: {what_is_gained} -- quantify: {amount}
5. RESTORE: {action} to return state (if needed before repayment)
6. REPAY: Call repay() with FlashLoanReceipt + {amount + fee}
7. PROFIT: {extract - fee - gas} = {net_profit}

Profitability gate: If net_profit <= 0 for all realistic amounts -> document as NON-PROFITABLE but check Step 3 for multi-call chains.

For each sequence, verify:

• Can steps 2-5 execute atomically (same transaction entry function)?
• Does any step abort under normal conditions?
• Is the manipulation detectable/preventable by the protocol?
• What is the minimum flash loan amount needed?
• Does the hot potato receipt constrain the call sequence? (receipt must be threaded through all calls)

3. Cross-Function Flash Loan Chains

Model multi-call atomic sequences within a single flash loan:

Key question: Can calling function A then function B in the same transaction produce a state that neither function alone could create?

Aptos-specific multi-call patterns:

• Deposit to pool -> manipulate price via swap -> withdraw at inflated rate
• Flash-stake to meet threshold -> trigger reward calculation -> unstake
• Borrow from protocol A -> manipulate collateral oracle via AMM trade -> liquidate on protocol B -> repay A
• Inflate FungibleStore balance via deposit -> trigger share price recalculation -> withdraw

3b. Flash-Loan-Enabled Debounce DoS

For each permissionless function with a cooldown/debounce that affects OTHER users (global cooldown, shared timestamp, epoch-bound action): Can attacker flash-borrow -> call debounced function -> trigger cooldown, blocking legitimate callers?

If cooldown is global/shared AND function is permissionless AND flash-triggerable -> FINDING (R2, minimum Medium).

3c. No-Op Resource Consumption

For each state-modifying function with a limited-use resource (cooldown, one-time flag, nonce, epoch-bound action): Can it be called with parameters producing zero economic effect (amount=0, same-token swap, self-transfer) while consuming the resource?

If a no-op call consumes a resource blocking legitimate use -> FINDING (R2, resource waste).

3d. External Flash x Debounce Cross-Reference (MANDATORY)

For EACH external protocol flagged as flash-susceptible in Section 0:

Cross-reference: Can the external flash loan trigger ANY debounce/cooldown found in Step 3b? If YES:

1. Is the debounce consumption permanent (no admin reset) or temporary (auto-expires)?
2. If permanent: is there ANY on-chain path to reset? (admin function, governance, time-based expiry)
3. Combined finding inherits the HIGHER severity of the two individual findings
4. Tag: [TRACE:flash({external}) -> call({debounce_fn}) -> cooldown consumed -> {duration/permanent}]

If no debounce functions exist from 3b: mark N/A and skip.

4. Flash Loan + Donation Compound Attacks

Combine flash loan capital with unsolicited token transfers:

Aptos-specific donation vectors:

• primary_fungible_store::deposit() -- can deposit to any address's primary store if the store exists
• coin::deposit<T>() -- can deposit to any address with a registered CoinStore
• Direct fungible_asset::deposit() with a FungibleStore reference
• Object-based stores may have different deposit access patterns

Check: Can a flash-borrowed amount be deposited (not through protocol's deposit logic) to the protocol's FungibleStore to manipulate balance() accounting, and then extracted via a subsequent protocol call within the same transaction?

5. Flash Loan Defense Audit

For each flash-loan-accessible attack path identified:

Aptos-specific defense notes:

• Move does NOT have native reentrancy guards (no nonReentrant modifier)
• Move's borrow checker prevents some reentrancy patterns at compile time (cannot borrow &mut twice)
• However, inter-module calls can create reentrancy-like patterns via public functions
• Hot potato pattern enforces same-transaction completion but does NOT prevent state manipulation between borrow and repay
• timestamp::now_seconds() granularity is per-second, not per-block -- same-second detection is unreliable

5b. Defense Parity Audit (Cross-Module)

For each user-facing action that exists in multiple modules or paths (stake, withdraw, claim, swap):

Key question: If ModuleA::stake() has a cooldown that prevents flash-stake-claim-withdraw, but ModuleB::stake() has NO cooldown for the same economic action -- can an attacker use ModuleB as the undefended path to extract the same value?

For each GAP found:

1. Can the undefended module be used to achieve the same economic outcome?
2. Does the defended module's protection become meaningless if the undefended path exists?
3. Is the defense difference intentional (documented via friend declarations) or accidental?

Instantiation Parameters

{CONTRACTS}              -- Move modules to analyze
{FLASH_LOAN_SOURCES}     -- Flash loan providers (Thala, Echelon, custom)
{RECEIPT_STRUCTS}         -- Hot potato receipt struct definitions
{FLASH_ACCESSIBLE_STATE} -- State variables manipulable via flash-borrowed capital
{EXTERNAL_PROTOCOLS}     -- External protocols whose state the contract reads

Finding Template

**ID**: [FL-N]
**Severity**: [based on profitability and fund impact]
**Step Execution**: checkmark1,2,3,4,5 | x(reasons) | ?(uncertain)
**Rules Applied**: [R2:Y, R4:Y, R10:Y, R15:Y]
**Location**: module::function:LineN
**Title**: Flash loan enables [manipulation] via [mechanism]
**Description**: [Full atomic attack sequence with amounts]
**Impact**: [Quantified profit/loss with realistic flash loan amounts]

Output Schema

Step Execution Checklist (MANDATORY)