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

chore: Remove old execution and encoding files (#221)

Browse Source 
They are unused now. See https://github.com/propeller-heads/tycho-execution for the new workflow
This commit is contained in:
greendianasaur
2025-06-24 14:37:00 +01:00
committed by GitHub
parent d4670d4312
commit cfbf6812bd
21 changed files with 0 additions and 1506 deletions
Download Patch File Download Diff File Expand all files Collapse all files

81
evm/test/BalancerSwapExecutor.t.sol
View File

@@ -1,81 +0,0 @@
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
import "./SwapExecutor.t.sol";
import "../src/balancer-v2/BalancerSwapExecutor.sol";
contract TestBalancerSwapExecutor is SwapExecutorTest {
BalancerSwapExecutor balancer;
IERC20 USDC = IERC20(USDC_ADDR);
IERC20 USDT = IERC20(USDT_ADDR);
constructor() {}
function setUp() public {
//Fork
uint256 forkBlock = 16000000;
vm.createSelectFork(vm.rpcUrl("mainnet"), forkBlock);
//Setup
balancer = new BalancerSwapExecutor();
}
function testBalancerSwap() public {
//Set up
uint256 sellAmount = 1000_000000;
uint256 expectedAmount = 998_919380; //Swap 1k USDT for 998 USDC
bool exactOut = false;
// This is required because balancer does a transferFrom sender.
// That also means we need to do this approval with our swapRouter.
bool tokenApprovalNeeded = true;
bytes memory protocolData = abi.encodePacked(
USDT_ADDR,
USDC_ADDR,
DAI_USDC_USDT_balancer,
bob,
exactOut,
tokenApprovalNeeded
);
// Logic
vm.prank(address(balancer));
deal(USDT_ADDR, address(balancer), sellAmount);
vm.prank(executor);
uint256 responseAmount = balancer.swap(sellAmount, protocolData);
//Assertions
assertEq(responseAmount, expectedAmount);
assertEq(USDC.balanceOf(bob), expectedAmount);
assertEq(USDT.balanceOf(address(balancer)), 0);
}
function testBalancerExactOutSwap() public {
//Set up
uint256 buyAmount = 1000_979168;
uint256 expectedSellAmount = 1000 * 10 ** 6;
bool exactOut = true;
bool tokenApprovalNeeded = true;
bytes memory protocolData = abi.encodePacked(
USDC_ADDR,
USDT_ADDR,
DAI_USDC_USDT_balancer,
bob,
exactOut,
tokenApprovalNeeded
);
//Logic
// This is required because balancer does a transferFrom sender.
// That also means we need to do this approval with our swapRouter.
vm.prank(address(balancer));
deal(USDC_ADDR, address(balancer), expectedSellAmount);
vm.prank(executor);
uint256 responseAmount = balancer.swap(buyAmount, protocolData);
// //Assertions
assertEq(responseAmount, expectedSellAmount);
assertEq(USDT.balanceOf(bob), buyAmount);
assertEq(USDC.balanceOf(address(balancer)), 0);
}
}

303
evm/test/CurveSwapExecutor.t.sol
View File

@@ -1,303 +0,0 @@
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
import "./SwapExecutor.t.sol";
import "../src/curve/CurveSwapExecutor.sol";
contract CurveSwapExecutorExposed is CurveSwapExecutor {
function decodeParams(bytes calldata data)
external
pure
returns (
IERC20 tokenOut,
address target,
address receiver,
uint8 poolType,
int128 i,
int128 j,
bool tokenApprovalNeeded
)
{
return _decodeParams(data);
}
}
contract CurveSwapExecutorPayable is CurveSwapExecutor {
receive() external payable {}
}
interface ILendingPool {
function deposit(
address asset,
uint256 amount,
address onBehalfOf,
uint16 referralCode
) external;
function withdraw(address asset, uint256 amount, address to)
external
returns (uint256);
}
contract TestCurveSwapExecutor is SwapExecutorTest {
CurveSwapExecutor swapMethod;
address swapMethodAddress;
// type 0 pool
address aDAI_ADDR = 0x028171bCA77440897B824Ca71D1c56caC55b68A3;
address aUSDC_ADDR = 0xBcca60bB61934080951369a648Fb03DF4F96263C;
IERC20 aDAI = IERC20(aDAI_ADDR);
IERC20 aUSDC = IERC20(aUSDC_ADDR);
address AAVE_POOL = 0xDeBF20617708857ebe4F679508E7b7863a8A8EeE;
// type 1 - 3pool
IERC20 DAI = IERC20(DAI_ADDR);
IERC20 USDC = IERC20(USDC_ADDR);
address THREE_POOL = 0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7;
// type 3 - tricrypto case
IERC20 WETH = IERC20(WETH_ADDR);
IERC20 WBTC = IERC20(WBTC_ADDR);
address TRICRYPTO_POOL = 0xD51a44d3FaE010294C616388b506AcdA1bfAAE46;
// type 4 - stETH
address stETH_ADDR = 0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84;
IERC20 stETH = IERC20(stETH_ADDR);
address stETH_POOL = 0xDC24316b9AE028F1497c275EB9192a3Ea0f67022;
// type 5 - LUSD
address LUSD_ADDR = 0x5f98805A4E8be255a32880FDeC7F6728C6568bA0;
IERC20 LUSD = IERC20(LUSD_ADDR);
IERC20 USDT = IERC20(USDT_ADDR);
address LUSD_POOL = 0xEd279fDD11cA84bEef15AF5D39BB4d4bEE23F0cA;
// type 6 - compound
address CPOOL = 0xA2B47E3D5c44877cca798226B7B8118F9BFb7A56;
// type 7
address LDO_POOL = 0x9409280DC1e6D33AB7A8C6EC03e5763FB61772B5;
IERC20 LDO = IERC20(LDO_ADDR);
// type 8
address CRV_POOL = 0x8301AE4fc9c624d1D396cbDAa1ed877821D7C511;
IERC20 CRV = IERC20(CRV_ADDR);
function setUp() public {
//Fork
uint256 forkBlock = 16000000;
vm.createSelectFork(vm.rpcUrl("mainnet"), forkBlock);
//Setup
swapMethod = new CurveSwapExecutor();
swapMethodAddress = address(swapMethod);
vm.makePersistent(swapMethodAddress);
}
// foundry deal doesn't work with the atokens:
// https://github.com/foundry-rs/forge-std/issues/140
function dealAaveDai() internal {
deal(DAI_ADDR, swapMethodAddress, 100_000 * 10 ** 18);
ILendingPool aave =
ILendingPool(0x7d2768dE32b0b80b7a3454c06BdAc94A69DDc7A9);
vm.startPrank(swapMethodAddress);
DAI.approve(address(aave), type(uint256).max);
aave.deposit(DAI_ADDR, 100_000 * 10 ** 18, swapMethodAddress, 0);
vm.stopPrank();
}
function testSwapType0() public {
dealAaveDai();
IERC20[] memory tokens = twoTokens(aDAI_ADDR, aUSDC_ADDR);
uint256 expAmountOut = 999647;
address receiver = bob;
bytes memory data =
getDataCurve(tokens[1], AAVE_POOL, receiver, 1, 0, 1, true);
uint256 amountOut = swapMethod.swap(10 ** 18, data);
uint256 finalBalance = aUSDC.balanceOf(receiver);
assertGe(finalBalance, expAmountOut);
assertEq(amountOut, expAmountOut);
}
// 3pool
function testSwapType1() public {
deal(DAI_ADDR, swapMethodAddress, 10_000 * 10 ** 18);
IERC20[] memory tokens = twoTokens(DAI_ADDR, USDC_ADDR);
uint256 expAmountOut = 999963;
address receiver = bob;
bytes memory data =
getDataCurve(tokens[1], THREE_POOL, receiver, 1, 0, 1, true);
uint256 amountOut = swapMethod.swap(10 ** 18, data);
uint256 finalBalance = USDC.balanceOf(receiver);
assertGe(finalBalance, expAmountOut);
assertEq(amountOut, expAmountOut);
}
// tricrypto
function testSwapType3() public {
deal(USDT_ADDR, swapMethodAddress, 10_000 * 10 ** 6);
IERC20[] memory tokens = twoTokens(USDT_ADDR, WBTC_ADDR);
uint256 expAmountOut = 60232482;
address receiver = bob;
bytes memory data =
getDataCurve(tokens[1], TRICRYPTO_POOL, receiver, 3, 0, 1, true);
uint256 amountOut = swapMethod.swap(10_000 * 10 ** 6, data);
uint256 finalBalance = WBTC.balanceOf(receiver);
assertGe(finalBalance, expAmountOut);
assertEq(amountOut, expAmountOut);
}
// stETH/ETH pool
function testSwapType4() public {
CurveSwapExecutorPayable swapMethodPayable =
new CurveSwapExecutorPayable();
address swapMethodPayableAddress = address(swapMethodPayable);
deal(WETH_ADDR, swapMethodPayableAddress, 100 * 10 ** 18);
IERC20[] memory tokens = twoTokens(WETH_ADDR, stETH_ADDR);
uint256 expAmountOut = 1011264689661846353;
bytes memory data = getDataCurve(
tokens[1], stETH_POOL, swapMethodPayableAddress, 4, 0, 1, false
);
vm.prank(swapMethodPayableAddress);
uint256 amountOut = swapMethodPayable.swap(10 ** 18, data);
uint256 finalBalance = stETH.balanceOf(swapMethodPayableAddress);
assertGe(finalBalance, expAmountOut);
// There is something weird with
// stETH that it gives me 1 Wei more here sometimes
assertGe(amountOut, expAmountOut);
// part 2 swap back stETH
tokens = twoTokens(stETH_ADDR, WETH_ADDR);
expAmountOut = 988069860569702379;
address receiver = bob;
data = getDataCurve(tokens[1], stETH_POOL, receiver, 4, 1, 0, true);
uint256 initialBalance = WETH.balanceOf(receiver);
amountOut = swapMethodPayable.swap(10 ** 18, data);
finalBalance = WETH.balanceOf(receiver) - initialBalance;
assertGe(finalBalance, expAmountOut);
assertEq(amountOut, expAmountOut);
}
// // metapool - LUSD
function testSwapType5() public {
deal(LUSD_ADDR, swapMethodAddress, 10_000 * 10 ** 18);
IERC20[] memory tokens = twoTokens(LUSD_ADDR, USDT_ADDR);
uint256 expAmountOut = 1035119;
address receiver = bob;
bytes memory data =
getDataCurve(tokens[1], LUSD_POOL, receiver, 5, 0, 3, true);
uint256 amountOut = swapMethod.swap(10 ** 18, data);
uint256 finalBalance = USDT.balanceOf(receiver);
assertGe(finalBalance, expAmountOut);
assertEq(amountOut, expAmountOut);
}
// Compound
function testSwapType6() public {
deal(DAI_ADDR, swapMethodAddress, 10_000 * 10 ** 18);
IERC20[] memory tokens = twoTokens(DAI_ADDR, USDC_ADDR);
uint256 expAmountOut = 999430;
address receiver = bob;
bytes memory data =
getDataCurve(tokens[1], CPOOL, receiver, 6, 0, 1, true);
uint256 amountOut = swapMethod.swap(10 ** 18, data);
uint256 finalBalance = USDC.balanceOf(receiver);
assertGe(finalBalance, expAmountOut);
assertEq(amountOut, expAmountOut);
}
// Curve v2
function testSwapType7() public {
vm.rollFork(17_000_000); //change block because this pool wasn't
// deployed at block 16M
uint256 amountIn = 10 ** 18;
uint256 expAmountOut = 743676671921315909289;
address receiver = bob;
deal(WETH_ADDR, swapMethodAddress, amountIn);
bytes memory data = abi.encodePacked(
getDataCurve(LDO, LDO_POOL, receiver, 7, 0, 1, true), receiver
);
uint256 amountOut = swapMethod.swap(amountIn, data);
uint256 finalBalance = LDO.balanceOf(bob);
assertGe(finalBalance, expAmountOut);
assertEq(amountOut, expAmountOut);
}
// Curve v2 2 token not factory pool
function testSwapType8() public {
vm.rollFork(17_000_000); //change block because this pool wasn't
// deployed at block 16M
uint256 amountIn = 10 ** 18;
uint256 expAmountOut = 1831110768300490995125;
address receiver = bob;
deal(WETH_ADDR, swapMethodAddress, amountIn);
bytes memory data = abi.encodePacked(
getDataCurve(CRV, CRV_POOL, receiver, 8, 0, 1, true), receiver
);
uint256 amountOut = swapMethod.swap(amountIn, data);
uint256 finalBalance = CRV.balanceOf(bob);
assertGe(finalBalance, expAmountOut);
assertEq(amountOut, expAmountOut);
}
function testDecodeParams() public {
CurveSwapExecutorExposed swapMethodExposed =
new CurveSwapExecutorExposed();
//Logic
bytes memory data = getDataCurve(LDO, LDO_POOL, bob, 7, 0, 1, true);
(
IERC20 tokenOut,
address target,
address receiver,
uint8 poolType,
int128 i,
int128 j,
bool tokenApprovalNeeded
) = swapMethodExposed.decodeParams(data);
//Assertions
assertEq(address(tokenOut), LDO_ADDR);
assertEq(address(target), LDO_POOL);
assertEq(address(receiver), bob);
assertEq(poolType, 7);
assertEq(i, 0);
assertEq(j, 1);
assertEq(tokenApprovalNeeded, true);
}
function getDataCurve(
IERC20 tokenOut,
address pool,
address receiver,
uint8 poolType,
uint8 i,
uint8 j,
bool tokenApprovalNeeded
) internal pure returns (bytes memory data) {
data = abi.encodePacked(
tokenOut, pool, receiver, poolType, i, j, tokenApprovalNeeded
);
}
}

18
evm/test/SwapExecutor.t.sol
View File

@@ -1,18 +0,0 @@
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
import "forge-std/Test.sol";
import "openzeppelin-contracts/contracts/interfaces/IERC20.sol";
import "./Constants.sol";
contract SwapExecutorTest is Test, Constants {
function twoTokens(address token0, address token1)
internal
pure
returns (IERC20[] memory tokens)
{
tokens = new IERC20[](2);
tokens[0] = IERC20(token0);
tokens[1] = IERC20(token1);
}
}