This guide is fully dedicated to the process of writing a smart contract that calls flash on a pool and swaps the full amount withdrawn of token0 and token1 in the corresponding pools with the same pair of tokens. After the swap is complete, the contract will pay back the pool and transfer profits to the original calling address.
Flash transactions are an approach to token transfers on Polygon in which token residues are transferred before the necessary conditions for transferring those residues have been met. In the context of a swap, this means that the output is sent from the swap before the input is received.
Flash is aimed at withdrawing a specified amount of both token0 and token1 to the recipient address. The withdrawn amount, plus the swap fees, will be due to the pool at the end of the transaction. Flash includes a fourth parameter, data, which allows the caller to abi.encode any necessary data to be passed through the function and decoded later.
function flash(
address recipient,
uint256 amount0,
uint256 amount1,
bytes calldata data
) external override lock noDelegateCall {
Now that we already know that flash is aimed to withdraw the tokens, we still have a question: how can they be paid back? To find the answer, we need to learn the flash function code in detail. Midway through the flash function, we see this:
IAlgebraFlashCallback(msg.sender).algebraFlashCallback(fee0, fee1, data);
This step calls the FlashCallback function on msg.sender - which passes the fee data needed to calculate the balances due to the pool, as well as any data encoded into the data parameter.
We can highlight three different, separate callback functions in Algebra. These are algebraSwapCallback, algebraMintCallback, and algebraFlashCallback, and each of them can be easily overridden by custom logic. To write our arbitrage contract, it is required to call flashand then override the algebraFlashCallback with the steps necessary to complete our transaction.
Inherit IAlgebraFlashCallback and PeripheryPayments, as we will use each of the above in our program. Note that these two inherited contracts already extend many of the other contracts we will be using in the future,such as LowGasSafeMath which we attach, to types uint256 and int256.
contract PairFlash is IAlgebraFlashCallback, PeripheryPayments {
using LowGasSafeMath for uint256;
using LowGasSafeMath for int256;
Declare an immutable public variable swapRouter of type ISwapRouter:
ISwapRouter public Immutable swapRouter;
Declare the constructor here, which is executed once when the contract is deployed. Our constructor hardcodes the address of the Algebra router, factory, and the address of wmatic, the ERC-20 wrapper for matic.
constructor(
ISwapRouter _swapRouter,
address _factory,
address _WMATIC9
) PeripheryImmutableState(_factory, _WMATIC9) {
swapRouter = _swapRouter;
}
The full import section and contract declaration:
pragma solidity =0.7.6;
pragma abicoder v2;
import '@cryptoalgebra/core/contracts/interfaces/callback/IAlgebraFlashCallback.sol';
import '@cryptoalgebra/core/contracts/libraries/LowGasSafeMath.sol';
import '@cryptoalgebra/periphery/contracts/base/PeripheryPayments.sol';
import '@cryptoalgebra/periphery/contracts/base/PeripheryImmutableState.sol';
import '@cryptoalgebra/periphery/contracts/libraries/PoolAddress.sol';
import '@cryptoalgebra/periphery/contracts/libraries/CallbackValidation.sol';
import '@cryptoalgebra/periphery/contracts/libraries/TransferHelper.sol';
import '@cryptoalgebra/periphery/contracts/interfaces/ISwapRouter.sol';
contract PairFlash is IAlgebraFlashCallback, PeripheryPayments {
using LowGasSafeMath for uint256;
using LowGasSafeMath for int256;
ISwapRouter public immutable swapRouter;
constructor(
ISwapRouter _swapRouter,
address _factory,
address _WMATIC9
) PeripheryImmutableState(_factory, _WMATIC9) {
swapRouter = _swapRouter;
}