Liquidity.Party/tycho-execution
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat: Add swap method with tests

Browse Source 
Changes:
- If the tokenIn is ETH, skip permit2 approval
- Make executors payable: When using delegatecall the executor inherits the execution context of whoever calls it. Our main swap function can accept ETH, it needs to be payable so by consequence the executors also need to be.
- Set uniswap v2 executor in test router
- Add tests for all possible cases of swap
- Add tests for all cases of splitSwap
- Add test functions to handle permit2 and encode swaps

--- don't change below this line ---
ENG-4041 Took 3 hours 50 minutes

Took 49 seconds


Took 14 seconds
This commit is contained in:
Diana Carvalho
2025-01-27 17:10:47 +00:00
parent a8f6fc1eec
commit 50429ad05c
7 changed files with 537 additions and 21 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
foundry/test/Constants.sol
View File

@@ -9,6 +9,10 @@ contract Constants is Test {
address FUND_RESCUER = makeAddr("fundRescuer");
address FEE_SETTER = makeAddr("feeSetter");
address FEE_RECEIVER = makeAddr("feeReceiver");
address EXECUTOR_SETTER = makeAddr("executorSetter");
address ALICE = 0xcd09f75E2BF2A4d11F3AB23f1389FcC1621c0cc2;
uint256 ALICE_PK =
0x123456789abcdef123456789abcdef123456789abcdef123456789abcdef1234;
// Dummy contracts
address DUMMY = makeAddr("dummy");
@@ -18,6 +22,14 @@ contract Constants is Test {
// Assets
address WETH_ADDR = address(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
address DAI_ADDR = address(0x6B175474E89094C44Da98b954EedeAC495271d0F);
address USDC_ADDR = address(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
address WBTC_ADDR = address(0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599);
// uniswap v2
address WETH_DAI_POOL = 0xA478c2975Ab1Ea89e8196811F51A7B7Ade33eB11;
address DAI_USDC_POOL = 0xAE461cA67B15dc8dc81CE7615e0320dA1A9aB8D5;
address WETH_WBTC_POOL = 0xBb2b8038a1640196FbE3e38816F3e67Cba72D940;
address USDC_WBTC_POOL = 0x004375Dff511095CC5A197A54140a24eFEF3A416;
/**
* @dev Deploys a dummy contract with non-empty bytecode

348
foundry/test/TychoRouter.t.sol
View File

@@ -206,11 +206,355 @@ contract TychoRouterTest is TychoRouterTestSetup {
uint256 amount = 1 ether;
deal(WETH_ADDR, address(tychoRouter), amount);
vm.startPrank(BOB);
tychoRouter.unwrapETH(amount);
vm.stopPrank();
assertEq(address(tychoRouter).balance, amount);
assertEq(IERC20(WETH_ADDR).balanceOf(address(tychoRouter)), 0);
}
function testSplitSwapSimple() public {
// Trade 1 WETH for DAI with 1 swap on Uniswap V2
// 1 WETH -> DAI
// (univ2)
uint256 amount_in = 1 ether;
deal(WETH_ADDR, address(tychoRouter), amount_in);
bytes memory protocolData =
encodeUniswapV2Swap(WETH_ADDR, WETH_DAI_POOL, ALICE, false);
bytes memory swap =
encodeSwap(uint8(0), uint8(1), uint24(0), protocolData);
bytes[] memory swaps = new bytes[](1);
swaps[0] = swap;
uint256 minAmountOut = 2600 * 1e18;
uint256 amountOut =
tychoRouter.splitSwap(amount_in, 2, pleEncode(swaps));
uint256 daiBalance = IERC20(DAI_ADDR).balanceOf(ALICE);
assertEq(daiBalance, 2630432278145144658455);
assertEq(IERC20(WETH_ADDR).balanceOf(ALICE), 0);
}
function testSplitSwapMultipleHops() public {
// Trade 1 WETH for USDC through DAI with 2 swaps on Uniswap V2
// 1 WETH -> DAI -> USDC
// (univ2) (univ2)
uint256 amount_in = 1 ether;
deal(WETH_ADDR, address(tychoRouter), amount_in);
bytes[] memory swaps = new bytes[](2);
// WETH -> DAI
swaps[0] = encodeSwap(
uint8(0),
uint8(1),
uint24(0),
encodeUniswapV2Swap(
WETH_ADDR, WETH_DAI_POOL, address(tychoRouter), false
)
);
// DAI -> USDC
swaps[1] = encodeSwap(
uint8(1),
uint8(2),
uint24(0),
encodeUniswapV2Swap(DAI_ADDR, DAI_USDC_POOL, ALICE, true)
);
uint256 minAmountOut = 2600 * 1e6;
uint256 amountOut =
tychoRouter.splitSwap(amount_in, 3, pleEncode(swaps));
uint256 usdcBalance = IERC20(USDC_ADDR).balanceOf(ALICE);
assertEq(usdcBalance, 2610580090);
assertEq(IERC20(WETH_ADDR).balanceOf(ALICE), 0);
}
function testSplitSwapSplitHops() public {
// Trade 1 WETH for USDC through DAI and WBTC with 4 swaps on Uniswap V2
// -> DAI ->
// 1 WETH USDC
// -> WBTC ->
// (univ2) (univ2)
uint256 amount_in = 1 ether;
deal(WETH_ADDR, address(tychoRouter), amount_in);
bytes[] memory swaps = new bytes[](4);
// WETH -> WBTC (60%)
swaps[0] = encodeSwap(
uint8(0),
uint8(1),
(0xffffff * 60) / 100, // 60%
encodeUniswapV2Swap(
WETH_ADDR, WETH_WBTC_POOL, address(tychoRouter), false
)
);
// WBTC -> USDC
swaps[1] = encodeSwap(
uint8(1),
uint8(2),
uint24(0),
encodeUniswapV2Swap(WBTC_ADDR, USDC_WBTC_POOL, ALICE, true)
);
// WETH -> DAI
swaps[2] = encodeSwap(
uint8(0),
uint8(3),
uint24(0),
encodeUniswapV2Swap(
WETH_ADDR, WETH_DAI_POOL, address(tychoRouter), false
)
);
// DAI -> USDC
swaps[3] = encodeSwap(
uint8(3),
uint8(2),
uint24(0),
encodeUniswapV2Swap(DAI_ADDR, DAI_USDC_POOL, ALICE, true)
);
uint256 minAmountOut = 2580 * 1e6;
uint256 amountOut =
tychoRouter.splitSwap(amount_in, 4, pleEncode(swaps));
uint256 usdcBalance = IERC20(USDC_ADDR).balanceOf(ALICE);
assertEq(usdcBalance, 2581503157);
assertEq(IERC20(WETH_ADDR).balanceOf(ALICE), 0);
}
function testSwapChecked() public {
// Trade 1 WETH for DAI with 1 swap on Uniswap V2
// Does permit2 token approval and transfer
// Checks amount out at the end
uint256 amount_in = 1 ether;
deal(WETH_ADDR, ALICE, amount_in);
vm.startPrank(ALICE);
(
IAllowanceTransfer.PermitSingle memory permitSingle,
bytes memory signature
) = handlePermit2Approval(WETH_ADDR, amount_in);
bytes memory protocolData =
encodeUniswapV2Swap(WETH_ADDR, WETH_DAI_POOL, ALICE, false);
bytes memory swap =
encodeSwap(uint8(0), uint8(1), uint24(0), protocolData);
bytes[] memory swaps = new bytes[](1);
swaps[0] = swap;
uint256 minAmountOut = 2600 * 1e18;
uint256 amountOut = tychoRouter.swap(
amount_in,
WETH_ADDR,
DAI_ADDR,
true,
minAmountOut,
false,
false,
2,
ALICE,
permitSingle,
signature,
pleEncode(swaps)
);
uint256 daiBalance = IERC20(DAI_ADDR).balanceOf(ALICE);
assertEq(daiBalance, 2630432278145144658455);
assertEq(IERC20(WETH_ADDR).balanceOf(ALICE), 0);
vm.stopPrank();
}
function testSwapCheckedFailure() public {
// Trade 1 WETH for DAI with 1 swap on Uniswap V2
// Does permit2 token approval and transfer
// Checks amount out at the end and fails
uint256 amount_in = 1 ether;
deal(WETH_ADDR, ALICE, amount_in);
vm.startPrank(ALICE);
(
IAllowanceTransfer.PermitSingle memory permitSingle,
bytes memory signature
) = handlePermit2Approval(WETH_ADDR, amount_in);
bytes memory protocolData =
encodeUniswapV2Swap(WETH_ADDR, WETH_DAI_POOL, ALICE, false);
bytes memory swap =
encodeSwap(uint8(0), uint8(1), uint24(0), protocolData);
bytes[] memory swaps = new bytes[](1);
swaps[0] = swap;
uint256 minAmountOut = 3000 * 1e18;
vm.expectRevert(
abi.encodeWithSelector(
TychoRouter__NegativeSlippage.selector,
2630432278145144658455, // actual amountOut
minAmountOut
)
);
uint256 amountOut = tychoRouter.swap(
amount_in,
WETH_ADDR,
DAI_ADDR,
true,
minAmountOut,
false,
false,
2,
ALICE,
permitSingle,
signature,
pleEncode(swaps)
);
vm.stopPrank();
}
function testSwapFee() public {
// Trade 1 WETH for DAI with 1 swap on Uniswap V2
// Does permit2 token approval and transfer
// Takes fee at the end
vm.startPrank(FEE_SETTER);
tychoRouter.setFee(100);
tychoRouter.setFeeReceiver(FEE_RECEIVER);
vm.stopPrank();
uint256 amount_in = 1 ether;
deal(WETH_ADDR, ALICE, amount_in);
vm.startPrank(ALICE);
(
IAllowanceTransfer.PermitSingle memory permitSingle,
bytes memory signature
) = handlePermit2Approval(WETH_ADDR, amount_in);
bytes memory protocolData = encodeUniswapV2Swap(
WETH_ADDR, WETH_DAI_POOL, address(tychoRouter), false
);
bytes memory swap =
encodeSwap(uint8(0), uint8(1), uint24(0), protocolData);
bytes[] memory swaps = new bytes[](1);
swaps[0] = swap;
uint256 amountOut = tychoRouter.swap(
amount_in,
WETH_ADDR,
DAI_ADDR,
false,
0,
false,
false,
2,
ALICE,
permitSingle,
signature,
pleEncode(swaps)
);
uint256 daiBalance = IERC20(DAI_ADDR).balanceOf(ALICE);
assertEq(daiBalance, 2604127955363693211871);
assertEq(IERC20(DAI_ADDR).balanceOf(FEE_RECEIVER), 26304322781451446584);
vm.stopPrank();
}
function testSwapWrapETH() public {
// Trade 1 ETH (and wrap it) for DAI with 1 swap on Uniswap V2
uint256 amount_in = 1 ether;
deal(ALICE, amount_in);
vm.startPrank(ALICE);
IAllowanceTransfer.PermitSingle memory emptyPermitSingle =
IAllowanceTransfer.PermitSingle({
details: IAllowanceTransfer.PermitDetails({
token: address(0),
amount: 0,
expiration: 0,
nonce: 0
}),
spender: address(0),
sigDeadline: 0
});
bytes memory protocolData =
encodeUniswapV2Swap(WETH_ADDR, WETH_DAI_POOL, ALICE, false);
bytes memory swap =
encodeSwap(uint8(0), uint8(1), uint24(0), protocolData);
bytes[] memory swaps = new bytes[](1);
swaps[0] = swap;
uint256 amountOut = tychoRouter.swap{value: amount_in}(
amount_in,
address(0),
DAI_ADDR,
false,
0,
true,
false,
2,
ALICE,
emptyPermitSingle,
"",
pleEncode(swaps)
);
uint256 daiBalance = IERC20(DAI_ADDR).balanceOf(ALICE);
assertEq(daiBalance, 2630432278145144658455);
assertEq(ALICE.balance, 0);
vm.stopPrank();
}
function testSwapUnwrapETH() public {
// Trade 3k DAI for WETH with 1 swap on Uniswap V2 and unwrap it at the end
uint256 amount_in = 3_000 * 10 ** 18;
deal(DAI_ADDR, ALICE, amount_in);
vm.startPrank(ALICE);
(
IAllowanceTransfer.PermitSingle memory permitSingle,
bytes memory signature
) = handlePermit2Approval(DAI_ADDR, amount_in);
bytes memory protocolData = encodeUniswapV2Swap(
DAI_ADDR, WETH_DAI_POOL, address(tychoRouter), true
);
bytes memory swap =
encodeSwap(uint8(0), uint8(1), uint24(0), protocolData);
bytes[] memory swaps = new bytes[](1);
swaps[0] = swap;
uint256 amountOut = tychoRouter.swap(
amount_in,
DAI_ADDR,
address(0),
false,
0,
false,
true,
2,
ALICE,
permitSingle,
signature,
pleEncode(swaps)
);
assertEq(ALICE.balance, 1132829934891544187); // 1.13 ETH
vm.stopPrank();
}
}

131
foundry/test/TychoRouterTestSetup.sol
View File

@@ -1,9 +1,10 @@
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
import "@src/TychoRouter.sol";
import "../src/executors/UniswapV2Executor.sol";
import "./Constants.sol";
import "./mock/MockERC20.sol";
import "@src/TychoRouter.sol";
import {WETH} from "../lib/permit2/lib/solmate/src/tokens/WETH.sol";
contract TychoRouterExposed is TychoRouter {
@@ -16,12 +17,20 @@ contract TychoRouterExposed is TychoRouter {
function unwrapETH(uint256 amount) external {
return _unwrapETH(amount);
}
function splitSwap(uint256 amountIn, uint256 nTokens, bytes calldata swaps)
external
returns (uint256)
{
return _splitSwap(amountIn, nTokens, swaps);
}
}
contract TychoRouterTestSetup is Test, Constants {
TychoRouterExposed tychoRouter;
address executorSetter;
address permit2Address = address(0x000000000022D473030F116dDEE9F6B43aC78BA3);
UniswapV2Executor public usv2Executor;
MockERC20[] tokens;
function setUp() public {
@@ -35,10 +44,18 @@ contract TychoRouterTestSetup is Test, Constants {
tychoRouter.grantRole(keccak256("FEE_SETTER_ROLE"), FEE_SETTER);
tychoRouter.grantRole(keccak256("PAUSER_ROLE"), PAUSER);
tychoRouter.grantRole(keccak256("UNPAUSER_ROLE"), UNPAUSER);
tychoRouter.grantRole(
keccak256("EXECUTOR_SETTER_ROLE"), EXECUTOR_SETTER
);
executorSetter = BOB;
deployDummyContract();
vm.stopPrank();
usv2Executor = new UniswapV2Executor();
vm.startPrank(EXECUTOR_SETTER);
tychoRouter.setExecutor(address(usv2Executor));
vm.stopPrank();
vm.startPrank(BOB);
tokens.push(new MockERC20("Token A", "A"));
tokens.push(new MockERC20("Token B", "B"));
@@ -57,4 +74,116 @@ contract TychoRouterTestSetup is Test, Constants {
tokens[i].mint(to, amount);
}
}
/**
* @dev Handles the Permit2 approval process for Alice, allowing the TychoRouter contract
* to spend `amount_in` of `tokenIn` on her behalf.
*
* This function approves the Permit2 contract to transfer the specified token amount
* and constructs a `PermitSingle` struct for the approval. It also generates a valid
* EIP-712 signature for the approval using Alice's private key.
*
* @param tokenIn The address of the token being approved.
* @param amount_in The amount of tokens to approve for transfer.
* @return permitSingle The `PermitSingle` struct containing the approval details.
* @return signature The EIP-712 signature for the approval.
*/
function handlePermit2Approval(address tokenIn, uint256 amount_in)
internal
returns (IAllowanceTransfer.PermitSingle memory, bytes memory)
{
IERC20(tokenIn).approve(permit2Address, amount_in);
IAllowanceTransfer.PermitSingle memory permitSingle = IAllowanceTransfer
.PermitSingle({
details: IAllowanceTransfer.PermitDetails({
token: tokenIn,
amount: uint160(amount_in),
expiration: uint48(block.timestamp + 1 days),
nonce: 0
}),
spender: address(tychoRouter),
sigDeadline: block.timestamp + 1 days
});
bytes memory signature = signPermit2(permitSingle, ALICE_PK);
return (permitSingle, signature);
}
/**
* @dev Signs a Permit2 `PermitSingle` struct with the given private key.
* @param permit The `PermitSingle` struct to sign.
* @param privateKey The private key of the signer.
* @return The signature as a `bytes` array.
*/
function signPermit2(
IAllowanceTransfer.PermitSingle memory permit,
uint256 privateKey
) internal returns (bytes memory) {
bytes32 _PERMIT_DETAILS_TYPEHASH = keccak256(
"PermitDetails(address token,uint160 amount,uint48 expiration,uint48 nonce)"
);
bytes32 _PERMIT_SINGLE_TYPEHASH = keccak256(
"PermitSingle(PermitDetails details,address spender,uint256 sigDeadline)PermitDetails(address token,uint160 amount,uint48 expiration,uint48 nonce)"
);
bytes32 domainSeparator = keccak256(
abi.encode(
keccak256(
"EIP712Domain(string name,uint256 chainId,address verifyingContract)"
),
keccak256("Permit2"),
block.chainid,
permit2Address
)
);
bytes32 detailsHash =
keccak256(abi.encode(_PERMIT_DETAILS_TYPEHASH, permit.details));
bytes32 permitHash = keccak256(
abi.encode(
_PERMIT_SINGLE_TYPEHASH,
detailsHash,
permit.spender,
permit.sigDeadline
)
);
bytes32 digest =
keccak256(abi.encodePacked("\x19\x01", domainSeparator, permitHash));
(uint8 v, bytes32 r, bytes32 s) = vm.sign(privateKey, digest);
return abi.encodePacked(r, s, v);
}
function pleEncode(bytes[] memory data)
public
pure
returns (bytes memory encoded)
{
for (uint256 i = 0; i < data.length; i++) {
encoded = bytes.concat(
encoded,
abi.encodePacked(bytes2(uint16(data[i].length)), data[i])
);
}
}
function encodeSwap(
uint8 tokenInIndex,
uint8 tokenOutIndex,
uint24 split,
bytes memory protocolData
) internal pure returns (bytes memory) {
return
abi.encodePacked(tokenInIndex, tokenOutIndex, split, protocolData);
}
function encodeUniswapV2Swap(
address tokenIn,
address target,
address receiver,
bool zero2one
) internal view returns (bytes memory) {
return abi.encodePacked(
usv2Executor, bytes4(0), tokenIn, target, receiver, zero2one
);
}
}

1
foundry/test/executors/UniswapV2Executor.t.sol
View File

@@ -34,7 +34,6 @@ contract UniswapV2ExecutorTest is UniswapV2ExecutorExposed, Test, Constants {
UniswapV2ExecutorExposed uniswapV2Exposed;
IERC20 WETH = IERC20(WETH_ADDR);
IERC20 DAI = IERC20(DAI_ADDR);
address WETH_DAI_POOL = 0xA478c2975Ab1Ea89e8196811F51A7B7Ade33eB11;
function setUp() public {
uint256 forkBlock = 17323404;