Flash loans

We’ll walk through a concrete example of a debt repayment using flash loans on Sepolia.

There is an example order for this particular case on Sepolia, including the corresponding on-chain transaction. The example was executed using an automated script that places and signs a flash loan order on the Sepolia network. The following sections of the tutorial include code snippets from this tool.

Setup

The setup for the flash loan example is as follows:

A Safe wallet at address 0x35eD9A9D1122A1544e031Cc92fCC7eA599e28D9C. We use a smart contract wallet so that smart contracts can initiate the withdrawal of the collateral token.
The Safe borrows 10,000 USDT on Aave using 500,000 USDC as collateral.
Aave is used as the flash loan lender.
The necessary ERC-20 approvals are set in the wallet:
- The collateral token (USDC) is approved for CoW's Vault Relayer contract to facilitate the trade.
- The borrowed token (USDT) is approved for the Aave pool contract to enable debt repayment.
The Safe must have a non-zero balance of the order's sell token (USDC in this case) to pass CoW Swap order validation, which serves as a spam protection measure.

The order itself intends to:

Request a flash loan to Aave of 5,000 USDT.
Use those 5,000 to partially repay the 10,000 USDT debt on Aave.
Withdraw 400,000 USDC from Aave.
Perform a trade on CoW Swap, selling up to 400,000 USDC for 5,002.5 USDT (borrowed amount + 0.05% flash loan fee on Aave).
Use the 5,002.5 USDT from the trade to fully repay the flash loan (including the fee).

info

Exchange ratios on the Sepolia network can be very inconsistent. To ensure successful execution of the order, a large amount of USDC is withdrawn from Aave and used in the trade.

General considerations when testing flash loans on Sepolia and Aave:

Token addresses in Aave may not correspond with tokens names in other dapps.
Token ratios may need to be balanced, and trading amounts adjusted accordingly.
Tokens in Aave can be obtained from the faucet.
Check withdrawal and borrowing availability of the tokens on Aave.

In a production network (e.g. mainnet), these considerations generally won’t apply.

Aave repay pre-hook

We need to define a pre-hook to repay the 5,000 USDT debt on Aave, ensuring the Aave pool allows us to withdraw the associated collateral.

As part of the settlement, we want to call the repay function on Aave's pool:

function repay(
    address asset,
    uint256 amount,
    uint256 interestRateMode,
    address onBehalfOf
) public virtual override returns (uint256)

The following Typescript code generates the corresponding function data using viem:

const repayTxData = encodeFunctionData({
    abi, // ABI definition for the repay function
    functionName: 'repay',
    args: [
      '0xaA8E23Fb1079EA71e0a56F48a2aA51851D8433D0', // asset: USDT
      '5000000000', // amount: 5,000 USDT (USDT has 6 decimals)
      2, // interestRateMode: 2 for variable
      '0x35eD9A9D1122A1544e031Cc92fCC7eA599e28D9C', // onBehalfOf: Safe address
    ]
  });

The repay call (as well as the withdraw call later on) must be executed as a pre-hook during the order settlement process. This ensures that the user has the collateral tokens available before the settlement contract pulls in the sell tokens from all settled orders.

To enable this, the pre-hook defines a transaction that will be sent to the Safe wallet. The Safe then executes the actual repay call to the Aave pool. The transaction can be built using the Safe Protocol Kit as shown below:

  const repaySafeTxData: SafeTransactionDataPartial = {
    to: '0x6Ae43d3271ff6888e7Fc43Fd7321a503ff738951', // Aave pool address in Sepolia
    value: '0',
    data: repayTxData, // created previously
    operation: OperationType.Call,
    nonce, // current Safe nonce + 1
  };

  const safeTransaction = await safe.createTransaction({ transactions: [repaySafeTxData] });
  const signedSafeTransaction = await safe.signTransaction(safeTransaction, SigningMethod.ETH_SIGN);
  const encodedSafeTransaction = await safe.getEncodedTransaction(signedSafeTransaction);

note

For this example, the nonce should be offset by 1 from the current Safe's nonce. This is necessary to avoid reusing the same nonce, since a separate transaction will be sent to emit the pre-signature for our order, which is required to make it executable in the first place.

Aave withdraw pre-hook

We need to define another pre-hook to withdraw 400,000 USDC from the Aave deposit. This ensures that our Safe wallet holds the necessary sell tokens for the order. Otherwise, the settlement contract would be unable to pull the funds from the Safe, causing the settlement to revert.

For this, we need to call the withdraw function on Aave's pool:

function withdraw(
    address asset,
    uint256 amount,
    address to
) public virtual override returns (uint256)

The corresponding function data can be created as follows:

  const txData = encodeFunctionData({
    abi, // ABI definition for the withdraw function
    functionName: 'withdraw',
    args: [
      '0x94a9d9ac8a22534e3faca9f4e7f2e2cf85d5e4c8', // asset: USDC
      '400000000000', // amount: 400,000 USDC (USDC has 6 decimals)
      '0x35eD9A9D1122A1544e031Cc92fCC7eA599e28D9C', // to: Safe address
    ]
  });

Like in the previous section, the withdraw call will be executed during the order settlement process via a Safe transaction, and can be built with:

  const safeTxData: SafeTransactionDataPartial = {
    to: '0x6Ae43d3271ff6888e7Fc43Fd7321a503ff738951', // Aave pool address in Sepolia
    value: '0',
    data: txData, // created previously
    operation: OperationType.Call,
    nonce, // current Safe nonce + 2
  }

  const safeTransaction = await safe.createTransaction({ transactions: [safeTxData] })
  const signedSafeTransaction = await safe.signTransaction(safeTransaction, SigningMethod.ETH_SIGN);
  const encodedSafeTransaction = await safe.getEncodedTransaction(signedSafeTransaction);

  return encodedSafeTransaction;

note

Just like the repay pre-hook, the nonce should be incremented to ensure it doesn't conflict with other transactions. Here, we increase it by 2 because there are two preceding transactions: the pre-signature and the repay pre-hook.

Building and publishing the order

With both the repay and withdraw pre-hooks in place, we can now build the metadata of our order:

  const appData = {
    metadata: {
      flashloan: {
        lender: config.AAVE_POOL_ADDRESS,
        token: USDT_ADDRESS,
        amount: "5000000000" // 5,000 USDT
      },
      hooks: {
        pre: [
          {
            target: config.SAFE_ADDRESS,
            value: "0",
            callData: repayTx, // repay pre-hook data
            gasLimit: "1000000"
          },
          {
            target: config.SAFE_ADDRESS,
            value: "0",
            callData: withdrawTx, // withdraw pre-hook data
            gasLimit: "1000000"
          }
        ],
        "post": []
      },
      signer: config.SAFE_ADDRESS,
    },
  };

To programmatically create and submit a CoW Swap order, we can use cow-sdk:

  // Setup CoW SDK
  const sdk = new TradingSdk({
    chainId: SupportedChainId.SEPOLIA,
    signer: new VoidSigner(config.SAFE_ADDRESS, new JsonRpcProvider(config.RPC_URL)),
    appCode: 'Our flashloan example',
  });

  // Define trade parameters
  const parameters: TradeParameters = {
    env: 'staging', // Required for Sepolia
    kind: OrderKind.BUY,
    sellToken: USDC_ADDRESS,
    sellTokenDecimals: 6, // USDC has 6 decimals
    buyToken: USDT_ADDRESS,
    buyTokenDecimals: 6, // USDT has 6 decimals as well
    amount: '5002500000', // 5,002.5 USDT (borrowed amount + 0.05% Aaave flash loan fee)
    // receiver is always the settlement contract because the driver takes
    // funds from the settlement contract to pay back the loan
    receiver: '0x9008D19f58AAbD9eD0D60971565AA8510560ab41', // cow settlement contract address on sepolia
  }

  const advancedParameters: SwapAdvancedSettings = {
    quoteRequest: {
      // An EIP-1271 signature could also be used instead
      signingScheme: SigningScheme.PRESIGN,
    },
    appData,
  }

  const orderId = await sdk.postSwapOrder(parameters, advancedParameters);
  console.log('Order created, id: ', orderId);

We've now placed our order on CoW Swap. You can track its progress on CoW Explorer. Here is an example of a filled order corresponding to the particular case shown in this tutorial.

Setting the pre-signature of the order

After placing the order, its pre-signature must be submitted by calling the setPresignature function on the CoW Settlement contract:

function setPreSignature(bytes calldata orderUid, bool signed) external;

To build and send the transaction through our Safe wallet:

  const txData = encodeFunctionData({
    abi, // ABI for the setPresignature function
    functionName: 'setPreSignature',
    args: [
      orderId,
      true,
    ]
  });

  const safeTransactionData: SafeTransactionDataPartial = {
    to: "0x9008D19f58AAbD9eD0D60971565AA8510560ab41", // CoW settlement contract on Sepolia
    value: '0',
    data: txData,
    operation: OperationType.Call,
  }

  const safeTransaction = await safe.createTransaction({ transactions: [safeTransactionData] });
  const signedSafeTransaction = await safe.signTransaction(safeTransaction, SigningMethod.ETH_SIGN);

  const transactionResult = await safe.executeTransaction(signedSafeTransaction);
  console.log('setPreSignature transaction hash: ' + transactionResult.hash);

After the pre-signature transaction is confirmed, the order's status will be Open, making it eligible for execution within the CoW Protocol.

note

This example uses a pre-signature, but a valid EIP-1271 contract signature could also be used. With an EIP-1271 signature, the setPreSignature transaction would not be necessary.

Order execution

Once an order is placed within the CoW Protocol, it enters an auction batch. When a solution is found, the following steps occur:

The winning solver calls the flash loan IFlashLoanRouter contract.
The 5,000 USDT gets transferred to the flash loan IFlashLoanRouter contract.
In the pre-hook:
- Transfer 5,000 USDC from the flash loan IFlashLoanRouter contract to the user.
- Execute the user's pre-hook: Repay the outstanding debt.
- The user receives their 400,000 USDC of collateral.
Transfer funds into the settlement contract.
Execute the user's order:
- Swap USDC for USDT.
Transfer funds to the receiver address (funds are sent to the settlement contract, which is to itself).
Execute the post-interaction
- Depending on the flash loan provider, either pay back 5,002.5 USDT to the flash loan provider from the settlement contract, or send the funds to the flash loan IFlashLoanRouter contract, and then send it to the flash loan provider.

State after the order's execution:

Some USDC may remain in the user’s wallet as surplus.
On Aave:
- The USDT debt is reduced from 10,000 to 5,000.
- The USDC collateral is reduced by 400,000.
The flash loan provider is fully repaid (5,002.5 USDT).

Setup​

Aave repay pre-hook​

Aave withdraw pre-hook​

Building and publishing the order​

Setting the pre-signature of the order​

Order execution​

Setup

Aave repay pre-hook

Aave withdraw pre-hook

Building and publishing the order

Setting the pre-signature of the order

Order execution