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

feat(adapters): Add new bytes parameter to swap

Browse Source 
that allows arbitrary data to be passed
This commit is contained in:
PierreMkt
2024-08-02 11:55:00 -04:00
parent 75e8bdf96f
commit 034d5ac8c2
13 changed files with 85 additions and 34 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
evm/src/angle/AngleAdapter.sol
View File

@@ -56,7 +56,8 @@ contract AngleAdapter is ISwapAdapter {
address sellToken,
address buyToken,
OrderSide side,
uint256 specifiedAmount
uint256 specifiedAmount,
bytes32
) external returns (Trade memory trade) {
if (specifiedAmount == 0) {
return trade;
@@ -223,7 +224,7 @@ contract AngleAdapter is ISwapAdapter {
interface IAgToken is IERC20 {
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
MINTER ROLE ONLY FUNCTIONS
MINTER ROLE ONLY FUNCTIONS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
/// @notice Lets a whitelisted contract mint agTokens
@@ -254,7 +255,7 @@ interface IAgToken is IERC20 {
function burnSelf(uint256 amount, address burner) external;
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
TREASURY ONLY FUNCTIONS
TREASURY ONLY FUNCTIONS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
/// @notice Adds a minter in the contract
@@ -274,7 +275,7 @@ interface IAgToken is IERC20 {
function setTreasury(address _treasury) external;
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
EXTERNAL FUNCTIONS
EXTERNAL FUNCTIONS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
/// @notice Checks whether an address has the right to mint agTokens

3
evm/src/balancer-v2/BalancerV2SwapAdapter.sol
View File

@@ -118,7 +118,8 @@ contract BalancerV2SwapAdapter is ISwapAdapter {
address sellToken,
address buyToken,
OrderSide side,
uint256 specifiedAmount
uint256 specifiedAmount,
bytes32 data
) external override returns (Trade memory trade) {
uint256 sellAmount;
IVault.SwapKind kind;

3
evm/src/etherfi/EtherfiAdapter.sol
View File

@@ -99,7 +99,8 @@ contract EtherfiAdapter is ISwapAdapter {
address sellToken,
address buyToken,
OrderSide side,
uint256 specifiedAmount
uint256 specifiedAmount,
bytes32
)
external
override

3
evm/src/integral/IntegralSwapAdapter.sol
View File

@@ -59,7 +59,8 @@ contract IntegralSwapAdapter is ISwapAdapter {
address sellToken,
address buyToken,
OrderSide side,
uint256 specifiedAmount
uint256 specifiedAmount,
bytes32 data
) external override returns (Trade memory trade) {
if (specifiedAmount == 0) {
return trade;

4
evm/src/interfaces/ISwapAdapter.sol
View File

@@ -54,6 +54,7 @@ interface ISwapAdapter is ISwapAdapterTypes {
* @param buyToken The token being bought.
* @param side The side of the trade (Sell or Buy).
* @param specifiedAmount The amount to be traded.
* @param data Additional arbitrary data for the swap.
* @return trade Trade struct representing the executed trade.
*/
function swap(
@@ -61,7 +62,8 @@ interface ISwapAdapter is ISwapAdapterTypes {
address sellToken,
address buyToken,
OrderSide side,
uint256 specifiedAmount
uint256 specifiedAmount,
bytes32 data
) external returns (Trade memory trade);
/// @notice Retrieves the limits for each token.

3
evm/src/template/TemplateSwapAdapter.sol
View File

@@ -22,7 +22,8 @@ contract TemplateSwapAdapter is ISwapAdapter {
address sellToken,
address buyToken,
OrderSide side,
uint256 specifiedAmount
uint256 specifiedAmount,
bytes32
) external returns (Trade memory trade) {
revert NotImplemented("TemplateSwapAdapter.swap");
}

3
evm/src/uniswap-v2/UniswapV2SwapAdapter.sol
View File

@@ -69,7 +69,8 @@ contract UniswapV2SwapAdapter is ISwapAdapter {
address sellToken,
address buyToken,
OrderSide side,
uint256 specifiedAmount
uint256 specifiedAmount,
bytes32
) external override returns (Trade memory trade) {
if (specifiedAmount == 0) {
return trade;

17
evm/test/AdapterTest.sol
View File

@@ -10,6 +10,7 @@ import "src/libraries/FractionMath.sol";
contract AdapterTest is Test, ISwapAdapterTypes {
using FractionMath for Fraction;
bytes32 mockData = bytes32(abi.encodePacked(false));
uint256 constant pricePrecision = 10e24;
string[] public stringPctgs = ["0%", "0.1%", "50%", "100%"];
@@ -99,7 +100,7 @@ contract AdapterTest is Test, ISwapAdapterTypes {
console2.log("TEST: Swapping %d of %s", amounts[j], tokenIn);
trade = adapter.swap(
poolId, tokenIn, tokenOut, OrderSide.Sell, amounts[j]
poolId, tokenIn, tokenOut, OrderSide.Sell, amounts[j], mockData
);
uint256 executedPrice =
trade.calculatedAmount * pricePrecision / amounts[j];
@@ -188,7 +189,12 @@ contract AdapterTest is Test, ISwapAdapterTypes {
);
}
try adapter.swap(
poolId, tokenIn, tokenOut, OrderSide.Sell, aboveLimitArray[0]
poolId,
tokenIn,
tokenOut,
OrderSide.Sell,
aboveLimitArray[0],
mockData
) {
revert("Pool shouldn't be able to swap above the sell limit");
} catch Error(string memory s) {
@@ -214,7 +220,12 @@ contract AdapterTest is Test, ISwapAdapterTypes {
adapter.price(poolId, tokenIn, tokenOut, aboveLimitArray);
adapter.swap(
poolId, tokenIn, tokenOut, OrderSide.Sell, aboveLimitArray[0]
poolId,
tokenIn,
tokenOut,
OrderSide.Sell,
aboveLimitArray[0],
mockData
);
}

7
evm/test/AngleAdapter.t.sol
View File

@@ -18,6 +18,7 @@ contract AngleAdapterTest is Test, ISwapAdapterTypes {
ITransmuter(0x00253582b2a3FE112feEC532221d9708c64cEFAb);
uint256 constant TEST_ITERATIONS = 100;
bytes32 mockData = bytes32(abi.encodePacked(false));
function setUp() public {
uint256 forkBlock = 18921770;
@@ -55,7 +56,7 @@ contract AngleAdapterTest is Test, ISwapAdapterTypes {
uint256 agEUR_balance = agEUR.balanceOf(address(this));
Trade memory trade = adapter.swap(
pair, address(EURC), address(agEUR), side, specifiedAmount
pair, address(EURC), address(agEUR), side, specifiedAmount, mockData
);
if (trade.calculatedAmount > 0) {
@@ -106,7 +107,7 @@ contract AngleAdapterTest is Test, ISwapAdapterTypes {
uint256 agEUR_balance = agEUR.balanceOf(address(this));
Trade memory trade = adapter.swap(
pair, address(agEUR), address(EURC), side, specifiedAmount
pair, address(agEUR), address(EURC), side, specifiedAmount, mockData
);
if (trade.calculatedAmount > 0) {
@@ -159,7 +160,7 @@ contract AngleAdapterTest is Test, ISwapAdapterTypes {
agEUR.approve(address(adapter), type(uint256).max);
}
trades[i] = adapter.swap(
pair, address(agEUR), address(EURC), side, amounts[i]
pair, address(agEUR), address(EURC), side, amounts[i], mockData
);
vm.revertTo(beforeSwap);
}

16
evm/test/BalancerV2SwapAdapter.t.sol
View File

@@ -111,7 +111,7 @@ contract BalancerV2SwapAdapterTest is AdapterTest {
uint256 weth_balance = IERC20(WETH).balanceOf(address(this));
Trade memory trade = adapter.swap(
B_80BAL_20WETH_POOL_ID, BAL, WETH, side, specifiedAmount
B_80BAL_20WETH_POOL_ID, BAL, WETH, side, specifiedAmount, mockData
);
if (trade.calculatedAmount > 0) {
@@ -149,7 +149,12 @@ contract BalancerV2SwapAdapterTest is AdapterTest {
deal(BAL, address(this), amounts[i]);
IERC20(BAL).approve(address(adapter), amounts[i]);
trades[i] = adapter.swap(
B_80BAL_20WETH_POOL_ID, BAL, WETH, OrderSide.Sell, amounts[i]
B_80BAL_20WETH_POOL_ID,
BAL,
WETH,
OrderSide.Sell,
amounts[i],
mockData
);
vm.revertTo(beforeSwap);
@@ -180,7 +185,12 @@ contract BalancerV2SwapAdapterTest is AdapterTest {
deal(BAL, address(this), amountIn);
IERC20(BAL).approve(address(adapter), amountIn);
trades[i] = adapter.swap(
B_80BAL_20WETH_POOL_ID, BAL, WETH, OrderSide.Buy, amounts[i]
B_80BAL_20WETH_POOL_ID,
BAL,
WETH,
OrderSide.Buy,
amounts[i],
mockData
);
vm.revertTo(beforeSwap);

40
evm/test/EtherfiAdapter.t.sol
View File

@@ -15,6 +15,7 @@ contract EtherfiAdapterTest is Test, ISwapAdapterTypes {
IeEth eEth;
uint256 constant TEST_ITERATIONS = 100;
bytes32 mockData = bytes32(abi.encodePacked(false));
function setUp() public {
uint256 forkBlock = 19218495;
@@ -72,7 +73,8 @@ contract EtherfiAdapterTest is Test, ISwapAdapterTypes {
address(address(0)),
address(eEth_),
OrderSide.Buy,
limits[0]
limits[0],
mockData
);
eEth_.approve(address(adapter), type(uint256).max);
@@ -87,7 +89,8 @@ contract EtherfiAdapterTest is Test, ISwapAdapterTypes {
address(address(0)),
address(eEth_),
OrderSide.Buy,
specifiedAmount
specifiedAmount,
mockData
);
eEth_.approve(address(adapter), specifiedAmount);
@@ -97,7 +100,12 @@ contract EtherfiAdapterTest is Test, ISwapAdapterTypes {
uint256 weEth_balance = weEth_.balanceOf(address(this));
Trade memory trade = adapter.swap(
pair, address(eEth_), address(weEth_), side, specifiedAmount
pair,
address(eEth_),
address(weEth_),
side,
specifiedAmount,
mockData
);
if (trade.calculatedAmount > 0) {
@@ -164,7 +172,8 @@ contract EtherfiAdapterTest is Test, ISwapAdapterTypes {
address(address(0)),
address(weEth_),
OrderSide.Buy,
limits[0]
limits[0],
mockData
);
weEth_.approve(address(adapter), type(uint256).max);
@@ -179,7 +188,8 @@ contract EtherfiAdapterTest is Test, ISwapAdapterTypes {
address(address(0)),
address(weEth_),
OrderSide.Buy,
specifiedAmount
specifiedAmount,
mockData
);
weEth_.approve(address(adapter), specifiedAmount);
@@ -194,7 +204,12 @@ contract EtherfiAdapterTest is Test, ISwapAdapterTypes {
uint256 realAmountWeEth_ = weEth_balance - weEth_bal_before;
Trade memory trade = adapter.swap(
pair, address(weEth_), address(eEth_), side, realAmountWeEth_
pair,
address(weEth_),
address(eEth_),
side,
realAmountWeEth_,
mockData
);
if (trade.calculatedAmount > 0) {
@@ -254,8 +269,9 @@ contract EtherfiAdapterTest is Test, ISwapAdapterTypes {
uint256 eth_balance = address(adapter).balance;
uint256 eEth_balance = eEth_.balanceOf(address(this));
Trade memory trade =
adapter.swap(pair, eth_, address(eEth_), side, specifiedAmount);
Trade memory trade = adapter.swap(
pair, eth_, address(eEth_), side, specifiedAmount, mockData
);
if (trade.calculatedAmount > 0) {
if (side == OrderSide.Buy) {
@@ -309,8 +325,9 @@ contract EtherfiAdapterTest is Test, ISwapAdapterTypes {
uint256 eth_balance = address(adapter).balance;
uint256 weEth_balance = weEth_.balanceOf(address(this));
Trade memory trade =
adapter.swap(pair, eth_, address(weEth_), side, specifiedAmount);
Trade memory trade = adapter.swap(
pair, eth_, address(weEth_), side, specifiedAmount, mockData
);
if (trade.calculatedAmount > 0) {
if (side == OrderSide.Buy) {
@@ -373,7 +390,8 @@ contract EtherfiAdapterTest is Test, ISwapAdapterTypes {
address(address(weEth)),
address(address(eEth)),
side,
amounts[i]
amounts[i],
mockData
);
vm.revertTo(beforeSwap);
}

6
evm/test/IntegralSwapAdapter.t.sol
View File

@@ -16,6 +16,7 @@ contract IntegralSwapAdapterTest is Test, ISwapAdapterTypes {
address constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
address constant USDC_WETH_PAIR = 0x2fe16Dd18bba26e457B7dD2080d5674312b026a2;
address constant relayerAddress = 0xd17b3c9784510E33cD5B87b490E79253BcD81e2E;
bytes32 mockData = bytes32(abi.encodePacked(false));
uint256 constant TEST_ITERATIONS = 100;
@@ -83,7 +84,7 @@ contract IntegralSwapAdapterTest is Test, ISwapAdapterTypes {
uint256 weth_balance_before = IERC20(WETH).balanceOf(address(this));
Trade memory trade =
adapter.swap(pair, USDC, WETH, side, specifiedAmount);
adapter.swap(pair, USDC, WETH, side, specifiedAmount, mockData);
if (trade.calculatedAmount > 0) {
if (side == OrderSide.Buy) {
@@ -138,7 +139,8 @@ contract IntegralSwapAdapterTest is Test, ISwapAdapterTypes {
deal(USDC, address(this), amounts[i]);
IERC20(USDC).approve(address(adapter), amounts[i]);
trades[i] = adapter.swap(pair, USDC, WETH, side, amounts[i]);
trades[i] =
adapter.swap(pair, USDC, WETH, side, amounts[i], mockData);
vm.revertTo(beforeSwap);
}

5
evm/test/UniswapV2SwapAdapter.t.sol
View File

@@ -88,7 +88,7 @@ contract UniswapV2PairFunctionTest is AdapterTest {
uint256 weth_balance = IERC20(WETH).balanceOf(address(this));
Trade memory trade =
adapter.swap(pair, USDC, WETH, side, specifiedAmount);
adapter.swap(pair, USDC, WETH, side, specifiedAmount, mockData);
if (trade.calculatedAmount > 0) {
if (side == OrderSide.Buy) {
@@ -133,7 +133,8 @@ contract UniswapV2PairFunctionTest is AdapterTest {
deal(USDC, address(this), amounts[i]);
IERC20(USDC).approve(address(adapter), amounts[i]);
trades[i] = adapter.swap(pair, USDC, WETH, side, amounts[i]);
trades[i] =
adapter.swap(pair, USDC, WETH, side, amounts[i], mockData);
vm.revertTo(beforeSwap);
}