Detailed Instructions

Before initiating the loan, you must identify a price discrepancy, or arbitrage opportunity, between two or more DEXs. For example, ETH might be priced at $3,000 on Uniswap V3 but $3,050 on SushiSwap. The core principle is to borrow, swap, and repay within a single transaction. First, calculate the exact profit potential after accounting for all fees (loan fee, gas, swap fees). Then, plan the precise sequence of operations your smart contract will perform. This is called the transaction flow.

• Sub-step 1: Use a price aggregator or custom script to monitor DEX pools for significant price differences.
• Sub-step 2: Calculate the required loan amount. For a meaningful example, you might target borrowing 100 ETH from the Aave V3 pool on Ethereum mainnet (Pool Address: 0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2).
• Sub-step 3: Map the exact swap routes. E.g., Borrow ETH -> Swap ETH for DAI on Uniswap -> Swap DAI for ETH on SushiSwap -> Repay ETH loan.

Tip: Always simulate the transaction using a tool like Tenderly or a forked network to ensure profitability and correct logic before deploying real funds.

Detailed Instructions

You must write a smart contract that adheres to the specific flash loan interface of your chosen lending protocol, such as Aave's IFlashLoanReceiver. The contract's main function will be called by the lending pool after it provides the funds. This function must contain your entire business logic and guarantee repayment by the end of the transaction. Key elements include implementing the executeOperation callback and ensuring proper access control.

• Sub-step 1: Inherit from the protocol's receiver interface. For Aave V3, start your contract with: contract MyFlashLoan is IFlashLoanSimpleReceiver.
• Sub-step 2: Within the executeOperation function, encode your swap calls using the borrowed assets. You will use the amount and premium parameters passed by the pool.
• Sub-step 3: Approve the DEX routers (e.g., Uniswap V3 Router 0xE592427A0AEce92De3Edee1F18E0157C05861564) to spend the borrowed tokens for the swap.
• Sub-step 4: Crucially, at the end of the function, transfer the total owed (principal + fee) back to the lending pool address.

Tip: Always include a receive() or fallback() function to accept the initial loan and use modifiers like onlyPool to restrict who can call the execution function.

Detailed Instructions

With your contract deployed, you now initiate the flash loan by calling the flashLoan or flashLoanSimple function on the lending pool's contract. You will specify the asset, amount, your contract address, and any params needed for your execution logic. The pool will send the funds to your contract, call its execution function, and wait for the repayment. This entire process is atomic—it succeeds or fails as one unit.

• Sub-step 1: Determine the exact function signature. For Aave V3's simple flash loan, the call is: pool.flashLoanSimple(receiverAddress, asset, amount, params, referralCode).
• Sub-step 2: Encode any necessary data into the params field. This could include the addresses of the DEX routers and the target tokens for your arbitrage path.
• Sub-step 3: Execute the transaction from an EOA (Externally Owned Account) you control. For our example, the call would be:

javascriptCopy
const tx = await aavePool.flashLoanSimple(
  '0xYourContractAddress',
  '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2', // WETH Address
  ethers.utils.parseEther('100'), // 100 ETH
  '0x', // Encoded swap parameters
  0 // Referral code
);

• Sub-step 4: Pay the required gas fee, which can be high due to the computational complexity of the transaction.

Tip: Set a high gas limit (e.g., 1,000,000+ units) and use a competitive gas price to ensure your transaction is mined before the arbitrage window closes.

Detailed Instructions

This step occurs inside your contract's executeOperation function. The lending pool has sent the borrowed assets. Your contract must now execute the pre-defined swap operations on one or more DEXs. The goal is to end up with more of the borrowed asset than you started with, enough to cover the loan premium. The premium for Aave is typically 0.09% of the borrowed amount. Finally, you must approve and transfer the total owed back to the pool.

• Sub-step 1: Perform the first swap. Using our example, swap 100 ETH for DAI on Uniswap via the exactInputSingle function.
• Sub-step 2: Take the received DAI and swap it back for ETH on SushiSwap, aiming for a higher amount of ETH than you borrowed.
• Sub-step 3: Calculate the repayment amount: repayment = borrowedAmount + (borrowedAmount * 0.09 / 100). For 100 ETH, this is 100.09 ETH.
• Sub-step 4: Approve the lending pool to pull the repayment: IERC20(asset).approve(poolAddress, repaymentAmount);.
• Sub-step 5: The function concludes, and control returns to the lending pool, which verifies the repayment. If the contract's balance of the borrowed asset is insufficient, the entire transaction reverts.

Tip: Any profit (the leftover ETH after repayment) remains in your contract. Include a function to withdraw these funds to your wallet after the transaction is confirmed.

Detailed Instructions

A flash loan is an uncollateralized loan that must be borrowed and repaid within a single blockchain transaction. To implement one, you must first understand the key players: the liquidity pool (like those on Aave or Uniswap V3), the initiator (your contract), and the callback function where repayment logic resides. Your development environment must be configured with tools like Hardhat or Foundry, Node.js, and the appropriate SDKs (e.g., ethers.js).

• Sub-step 1: Install Dependencies: Run npm install @aave/protocol-v2 @openzeppelin/contracts to get the Aave V2 interfaces and security libraries.
• Sub-step 2: Set Up Network: Configure your hardhat.config.js to connect to a forked mainnet or a testnet like Sepolia for safe testing.
• Sub-step 3: Acquire Test Tokens: Use a faucet to get ETH on Sepolia, which you'll need for gas fees when deploying and interacting with your contract.

Tip: Always study the specific flash loan provider's documentation (e.g., Aave's IFlashLoanReceiver interface) as the exact function signatures and fee structures can differ.

Detailed Instructions

Your contract must implement the lender's specific interface. For Aave V2 on Ethereum mainnet, this is the IFlashLoanReceiver interface and its critical executeOperation function. This function is called by the Aave LendingPool (address: 0x7d2768dE32b0b80b7a3454c06BdAc94A69DDc7A9) after it sends you the borrowed assets. The contract must also track any premium, which is a 0.09% fee on the borrowed amount.

• Sub-step 1: Import Interfaces: Start your Solidity file with import "@aave/protocol-v2/contracts/flashloan/interfaces/IFlashLoanReceiver.sol";
• Sub-step 2: Declare Contract: Define your contract, e.g., contract MyFlashLoan is IFlashLoanReceiver.
• Sub-step 3: Implement Callback: Write the executeOperation function skeleton. It must accept parameters for the assets, amounts, premiums, and an initiator address, and return a boolean.

solidityCopy
function executeOperation(
    address[] calldata assets,
    uint256[] calldata amounts,
    uint256[] calldata premiums,
    address initiator,
    bytes calldata params
) external override returns (bool) {
    // Your arbitrage or swap logic goes here
    // MUST repay the loan + premium before returning
    return true;
}

Detailed Instructions

This step involves two main functions: one to trigger the loan and the executeOperation callback where you use the funds. To request a loan, you call flashLoan on the Aave LendingPool. You must specify the asset (e.g., DAI at 0x6B175474E89094C44Da98b954EedeAC495271d0F), the amount (e.g., 1000000000000000000 for 1 DAI, accounting for 18 decimals), and your contract's address as the receiver.

• Sub-step 1: Create Request Function: Write a initiateFlashLoan function in your contract that calls LendingPool.flashLoan().
• Sub-step 2: Implement Arbitrage Logic: Inside executeOperation, use the borrowed assets. A classic example is a DEX arbitrage: swap borrowed DAI for USDC on Uniswap, then swap that USDC back for more DAI on Sushiswap.
• Sub-step 3: Calculate Repayment: Before the function ends, you must repay the principal plus the premium. For 1 DAI, the premium is amount * 9 / 10000, which equals 0.0009 DAI.

solidityCopy
// Inside executeOperation, for a single asset loan:
uint256 amountOwed = amounts[0] + premiums[0];
IERC20(assets[0]).approve(address(LENDING_POOL), amountOwed);

Tip: All profit must be extracted within executeOperation. Any leftover tokens after repayment are your profit and should be sent back to the initiator.

Detailed Instructions

Security is paramount. You must test every edge case to avoid losing funds to reversion or being liquidated. Use a forked mainnet in Hardhat (npx hardhat node --fork https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY) to simulate real transactions without cost. Write comprehensive tests that verify the contract's balance increases after a successful arbitrage loop and that it reverts if the loan is not repaid.

• Sub-step 1: Write Unit Tests: Create a test file that simulates calling initiateFlashLoan and checks the executeOperation callback. Use chai assertions to verify ending balances.
• Sub-step 2: Deploy to Testnet: Compile with npx hardhat compile and deploy to Sepolia using a script: npx hardhat run scripts/deploy.js --network sepolia.
• Sub-step 3: Execute a Live Loan: On mainnet, call your deployed contract's function with a sensible amount (start small!). You will need ETH for gas. Monitor the transaction on Etherscan to confirm it succeeded and did not revert.

Tip: Always include a require(initiator == address(this)) check at the start of executeOperation to prevent malicious calls, and ensure you handle the approval for repayment for each borrowed asset.