Flash loans in Blockchain / Solidity - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Solidity flash loan example?

Consider this simplified Solidity code snippet for a flash loan. What will be the value of balanceAfter after the executeFlashLoan function runs successfully?

Blockchain / Solidity

contract FlashLoanExample {
    uint256 public balanceAfter;

    function executeFlashLoan(uint256 amount) external {
        uint256 balanceBefore = address(this).balance;
        // Simulate flash loan received
        uint256 loan = amount;
        // Use the loan for some operation (omitted)
        // Repay the loan
        balanceAfter = address(this).balance;
        require(balanceAfter >= balanceBefore, "Loan not repaid");
    }
}

A balanceAfter is less than balanceBefore, causing the require to fail and revert.

B balanceAfter is zero because the contract balance is reset after the function.

C balanceAfter is greater than balanceBefore, indicating profit from the loan.

D balanceAfter equals balanceBefore, meaning the loan was fully repaid.

💡 Hint

Think about what the require statement enforces about the contract's balance after the loan.

The require statement ensures the contract's balance after the flash loan operation is at least the same as before, meaning the loan must be fully repaid within the transaction. Therefore, balanceAfter equals balanceBefore.

🧠 Conceptual

intermediate

Why are flash loans considered risk-free for lenders?

Which of the following best explains why flash loans do not expose lenders to default risk?

A Because the lender holds the borrower's private keys during the loan.

B Because the loan is given only to trusted addresses with collateral.

C Because the loan must be repaid within the same transaction or the whole transaction reverts.

D Because the loan amount is always very small and insured by the protocol.

💡 Hint

Think about what happens if the borrower does not repay the loan in the same transaction.

Flash loans require the borrower to repay the loan within the same blockchain transaction. If repayment does not happen, the entire transaction is reverted, so the lender never loses funds.

🔧 Debug

advanced

Identify the error in this flash loan repayment code snippet

This Solidity function attempts to repay a flash loan but causes a runtime error. What is the cause?

Blockchain / Solidity

function repayLoan(uint256 amount) external {
    // Attempt to repay loan
    (bool success, ) = lender.call{value: amount}();
    require(success, "Repayment failed");
}

A The call is missing the function signature, so it sends plain Ether without calling repay function.

B The amount variable is not declared, causing a compilation error.

C The call should use transfer() instead of call() to send Ether.

D The require statement is incorrectly placed after the call.

💡 Hint

Consider how low-level call works when sending Ether and invoking functions.

Using call with only value sends Ether but does not specify which function to call on the lender contract. If the lender expects a function call to repay the loan, this will fail or not behave as intended.

📝 Syntax

advanced

Which option correctly defines a flash loan function in Solidity?

Select the option that correctly declares a flash loan function that takes a loan amount and a callback address.

A function flashLoan(uint256 amount, address callback) external { ... }

B function flashLoan(uint amount, address callback) public returns (bool) { ... }

C function flashLoan(uint256 amount, address callback) external payable { ... }

D function flashLoan(uint256 amount, address callback) external view { ... }

💡 Hint

Remember that flash loan functions usually modify state and do not return values.

The correct syntax uses uint256 for amount, external visibility, and no view modifier because the function changes state. It also does not return a value.

🚀 Application

expert

How many external calls are made in this flash loan transaction?

Given this sequence in a flash loan transaction: 1. Borrower requests loan from lender contract. 2. Lender contract calls borrower's executeOperation function. 3. Borrower performs arbitrage and repays lender. How many external contract calls occur during this transaction?

A 4

B 2

C 3

D 1

💡 Hint

Count calls between different contracts, including lender to borrower and borrower to lender.

There are two external calls: lender calls borrower (executeOperation), and borrower calls lender to repay. The initial request is a transaction from an EOA, not a contract call.

Practice

1. What is the main feature of a flash loan in blockchain?

easy

A. You can borrow funds without collateral but must repay within the same transaction

B. You borrow funds with collateral and repay anytime

C. You borrow funds and repay after 30 days

D. You borrow funds only for staking purposes

Solution

1. Step 1: Understand flash loan basics

   Flash loans allow borrowing without collateral but require repayment in the same transaction.

2. Step 2: Compare options

   Only You can borrow funds without collateral but must repay within the same transaction correctly states no collateral and instant repayment.

3. Final Answer:

   You can borrow funds without collateral but must repay within the same transaction -> Option A

4. Quick Check:

   Flash loan = no collateral + instant repayment [OK]

Hint: Flash loans = borrow now, repay instantly [OK]

Common Mistakes:

• Thinking collateral is required
• Assuming repayment can be delayed
• Confusing flash loans with regular loans

2. Which of the following is the correct Solidity function signature to implement a flash loan callback?

easy

A. function repayLoan(uint256 amount) external

B. function flashLoan(address borrower, uint256 amount) public

C. function startLoan(address asset, uint256 amount) external returns (bool)

D. function executeOperation(address[] calldata assets, uint256[] calldata amounts, uint256[] calldata premiums, address initiator, bytes calldata params) external returns (bool)

Solution

1. Step 1: Identify the standard flash loan callback

   The Aave protocol requires implementing executeOperation with specific parameters.

2. Step 2: Match function signature

   function executeOperation(address[] calldata assets, uint256[] calldata amounts, uint256[] calldata premiums, address initiator, bytes calldata params) external returns (bool) matches the exact signature needed for flash loan execution and repayment.

3. Final Answer:

   function executeOperation(address[] calldata assets, uint256[] calldata amounts, uint256[] calldata premiums, address initiator, bytes calldata params) external returns (bool) -> Option D

4. Quick Check:

   executeOperation signature = function executeOperation(address[] calldata assets, uint256[] calldata amounts, uint256[] calldata premiums, address initiator, bytes calldata params) external returns (bool) [OK]

Hint: Flash loan callback is always executeOperation with specific params [OK]

Common Mistakes:

• Using incorrect function names
• Missing required parameters
• Wrong return type

3. Given this simplified Solidity snippet inside executeOperation:

uint256 amountOwing = amounts[0] + premiums[0];
IERC20(assets[0]).approve(address(LENDING_POOL), amountOwing);
return true;

What does this code do?

medium

A. Transfers the loan amount to the borrower

B. Approves the lending pool to withdraw the loan plus fee for repayment

C. Withdraws the loan amount from the lending pool

D. Rejects the flash loan request

Solution

1. Step 1: Understand the approval call

   The code approves the lending pool contract to spend the loan amount plus premium from this contract.

2. Step 2: Interpret the purpose

   This approval is necessary so the lending pool can pull repayment automatically after the operation.

3. Final Answer:

   Approves the lending pool to withdraw the loan plus fee for repayment -> Option B

4. Quick Check:

   approve() = allow repayment withdrawal [OK]

Hint: approve() lets lending pool pull repayment [OK]

Common Mistakes:

• Confusing approve with transfer
• Thinking it sends funds to borrower
• Missing the premium fee in amount

4. Identify the error in this simplified flash loan executeOperation snippet:

function executeOperation(address[] calldata assets, uint256[] calldata amounts, uint256[] calldata premiums, address initiator, bytes calldata params) external returns (bool) {
    uint256 amountOwing = amounts[0] + premiums[0];
    IERC20(assets[0]).transferFrom(msg.sender, address(this), amountOwing);
    return true;
}

medium

A. Incorrect function parameters

B. Missing return statement

C. Using transferFrom instead of approve for repayment

D. Not calling the lending pool to borrow funds

Solution

1. Step 1: Analyze repayment method

   The code tries to pull repayment using transferFrom from msg.sender, which is incorrect.

2. Step 2: Correct repayment approach

   Flash loans require approving the lending pool to pull funds, not transferring from msg.sender.

3. Final Answer:

   Using transferFrom instead of approve for repayment -> Option C

4. Quick Check:

   Repayment needs approve(), not transferFrom() [OK]

Hint: Repay by approve(), not transferFrom() [OK]

Common Mistakes:

• Confusing transferFrom with approve
• Forgetting to approve lending pool
• Misunderstanding msg.sender role

5. You want to use a flash loan to perform arbitrage between two decentralized exchanges (DEXs). Which sequence correctly describes the steps inside executeOperation to profit and repay the loan?

hard

A. Borrow funds -> Buy low on DEX1 -> Sell high on DEX2 -> Approve repayment -> Return true

B. Borrow funds -> Approve repayment -> Buy low on DEX1 -> Sell high on DEX2 -> Return true

C. Approve repayment -> Borrow funds -> Buy low on DEX1 -> Sell high on DEX2 -> Return true

D. Buy low on DEX1 -> Borrow funds -> Sell high on DEX2 -> Approve repayment -> Return true

Solution

1. Step 1: Understand flash loan flow

   You first borrow funds, then use them to buy low on one DEX and sell high on another to gain profit.

2. Step 2: Approve repayment and finish

   After trading, approve the lending pool to pull the loan plus fee, then return true to complete.

3. Final Answer:

   Borrow funds -> Buy low on DEX1 -> Sell high on DEX2 -> Approve repayment -> Return true -> Option A

4. Quick Check:

   Arbitrage flow = borrow -> trade -> approve -> return [OK]

Hint: Trade first, then approve repayment [OK]

Common Mistakes:

• Approving repayment before trading
• Trying to trade before borrowing
• Not approving repayment at all