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

test: fix all aggregate order tests and a few executor bugs

Browse Source
This commit is contained in:
pedrobergamini
2025-06-17 23:27:03 -03:00
parent a777ab6adc
commit 90ac0a4c98
5 changed files with 561 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files

567
foundry/test/executors/BebopExecutor.t.sol
View File

@@ -48,7 +48,7 @@ contract BebopExecutorHarness is BebopExecutor, Test {
uint256 filledTakerAmount,
bytes memory quoteData,
bytes memory makerSignaturesData,
bool approvalNeeded
bool // approvalNeeded - unused in test harness
)
{
return _decodeData(data);
@@ -85,8 +85,27 @@ contract BebopExecutorHarness is BebopExecutor, Test {
givenAmount, order.taker_amount, filledTakerAmount
);
// Transfer tokens to executor
_transfer(address(this), transferType, tokenIn, givenAmount);
if (tokenIn != address(0)) {
// Transfer tokens to executor
_transfer(address(this), transferType, tokenIn, givenAmount);
}
// NOTE: NOT NEEDED FOR TESTING
// // Approve Bebop settlement to spend tokens if needed
// if (approvalNeeded) {
// // slither-disable-next-line unused-return
// IERC20(tokenIn).forceApprove(bebopSettlement, type(uint256).max);
// }
// NOTE: SETUP FOR TESTING
// Record balances before swap to calculate amountOut
uint256 balanceBefore = tokenOut == address(0)
? order.receiver.balance
: IERC20(tokenOut).balanceOf(order.receiver);
// Execute the swap with ETH value if needed
uint256 ethValue = tokenIn == address(0) ? actualFilledTakerAmount : 0;
// For testing: transfer tokens from executor to taker address
// This simulates the taker having the tokens with approval
@@ -101,16 +120,12 @@ contract BebopExecutorHarness is BebopExecutor, Test {
vm.startPrank(order.taker_address);
IERC20(tokenIn).forceApprove(bebopSettlement, type(uint256).max);
vm.stopPrank();
} else {
vm.stopPrank();
// For native ETH, send it to the taker address
payable(order.taker_address).transfer(actualFilledTakerAmount);
}
// Record balances before swap to calculate amountOut
uint256 balanceBefore = tokenOut == address(0)
? order.receiver.balance
: IERC20(tokenOut).balanceOf(order.receiver);
// Execute the swap with ETH value if needed
uint256 ethValue = tokenIn == address(0) ? actualFilledTakerAmount : 0;
// IMPORTANT: Prank as the taker address to pass the settlement validation
vm.stopPrank();
vm.startPrank(order.taker_address);
@@ -129,6 +144,8 @@ contract BebopExecutorHarness is BebopExecutor, Test {
vm.warp(currentTimestamp);
vm.stopPrank();
// NOTE: END SETUP FOR TESTING
// Calculate actual amount received
uint256 balanceAfter = tokenOut == address(0)
? order.receiver.balance
@@ -146,80 +163,100 @@ contract BebopExecutorHarness is BebopExecutor, Test {
uint256 filledTakerAmount,
bytes memory quoteData,
bytes memory makerSignaturesData,
bool approvalNeeded
bool // approvalNeeded - unused in test harness
) internal virtual override returns (uint256 amountOut) {
// // Decode the Aggregate order
// IBebopSettlement.Aggregate memory order =
// abi.decode(quoteData, (IBebopSettlement.Aggregate));
// Decode the Aggregate order
IBebopSettlement.Aggregate memory order =
abi.decode(quoteData, (IBebopSettlement.Aggregate));
// // Decode the MakerSignature array (can contain multiple signatures for Aggregate orders)
// IBebopSettlement.MakerSignature[] memory signatures =
// abi.decode(makerSignaturesData, (IBebopSettlement.MakerSignature[]));
// Decode the MakerSignature array (can contain multiple signatures for Aggregate orders)
IBebopSettlement.MakerSignature[] memory signatures =
abi.decode(makerSignaturesData, (IBebopSettlement.MakerSignature[]));
// // Aggregate orders should have at least one signature
// if (signatures.length == 0) {
// revert BebopExecutor__InvalidInput();
// }
// Aggregate orders should have at least one signature
if (signatures.length == 0) {
revert BebopExecutor__InvalidInput();
}
// // For aggregate orders, calculate total taker amount across all makers
// uint256 totalTakerAmount = 0;
// for (uint256 i = 0; i < order.taker_amounts.length; i++) {
// totalTakerAmount += order.taker_amounts[i][0];
// }
// uint256 actualFilledTakerAmount = _getActualFilledTakerAmount(
// givenAmount, totalTakerAmount, filledTakerAmount
// );
// For aggregate orders, calculate total taker amount across all amounts of the 2D array
uint256 totalTakerAmount;
for (uint256 i = 0; i < order.taker_amounts.length; i++) {
for (uint256 j = 0; j < order.taker_amounts[i].length; j++) {
totalTakerAmount += order.taker_amounts[i][j];
}
}
// // Transfer tokens to executor
// _transfer(address(this), transferType, tokenIn, givenAmount);
uint256 actualFilledTakerAmount = _getActualFilledTakerAmount(
givenAmount, totalTakerAmount, filledTakerAmount
);
// // For testing: transfer tokens from executor to taker address
// // This simulates the taker having the tokens with approval
// if (tokenIn != address(0)) {
// IERC20(tokenIn).safeTransfer(
// order.taker_address, actualFilledTakerAmount
// );
if (tokenIn != address(0)) {
// Transfer tokens to executor
_transfer(address(this), transferType, tokenIn, givenAmount);
}
// // Approve settlement from taker's perspective
// // Stop any existing prank first
// vm.stopPrank();
// vm.startPrank(order.taker_address);
// NOTE: NOT NEEDED FOR TESTING
// // Approve Bebop settlement to spend tokens if needed
// if (approvalNeeded) {
// // slither-disable-next-line unused-return
// IERC20(tokenIn).forceApprove(bebopSettlement, type(uint256).max);
// vm.stopPrank();
// }
// // Record balances before swap to calculate amountOut
// uint256 balanceBefore = tokenOut == address(0)
// ? order.receiver.balance
// : IERC20(tokenOut).balanceOf(order.receiver);
// NOTE: SETUP FOR TESTING
// // Execute the swap with ETH value if needed
// uint256 ethValue = tokenIn == address(0) ? actualFilledTakerAmount : 0;
// Record balances before swap to calculate amountOut
uint256 balanceBefore = tokenOut == address(0)
? order.receiver.balance
: IERC20(tokenOut).balanceOf(order.receiver);
// // IMPORTANT: Prank as the taker address to pass the settlement validation
// vm.stopPrank();
// vm.startPrank(order.taker_address);
// Execute the swap with ETH value if needed
uint256 ethValue = tokenIn == address(0) ? actualFilledTakerAmount : 0;
// // Set block timestamp to ensure order is valid regardless of fork block
// uint256 currentTimestamp = block.timestamp;
// vm.warp(order.expiry - 1); // Set timestamp to just before expiry
// For testing: transfer tokens from executor to taker address
// This simulates the taker having the tokens with approval
if (tokenIn != address(0)) {
IERC20(tokenIn).safeTransfer(
order.taker_address, actualFilledTakerAmount
);
// // Execute the swap - tokens are now in taker's wallet with approval
// // slither-disable-next-line arbitrary-send-eth
// IBebopSettlement(bebopSettlement).swapAggregate{value: ethValue}(
// order, signatures, actualFilledTakerAmount
// );
// Approve settlement from taker's perspective
// Stop any existing prank first
vm.stopPrank();
vm.startPrank(order.taker_address);
IERC20(tokenIn).forceApprove(bebopSettlement, type(uint256).max);
vm.stopPrank();
} else {
vm.stopPrank();
// For native ETH, send it to the taker address
payable(order.taker_address).transfer(actualFilledTakerAmount);
}
// // Restore original timestamp
// vm.warp(currentTimestamp);
// vm.stopPrank();
// IMPORTANT: Prank as the taker address to pass the settlement validation
vm.stopPrank();
vm.startPrank(order.taker_address);
// // Calculate actual amount received
// uint256 balanceAfter = tokenOut == address(0)
// ? order.receiver.balance
// : IERC20(tokenOut).balanceOf(order.receiver);
// Set block timestamp to ensure order is valid regardless of fork block
uint256 currentTimestamp = block.timestamp;
vm.warp(order.expiry - 1); // Set timestamp to just before expiry
// amountOut = balanceAfter - balanceBefore;
// Use swapAggregate - tokens are now in taker's wallet with approval
// slither-disable-next-line arbitrary-send-eth
IBebopSettlement(bebopSettlement).swapAggregate{value: ethValue}(
order, signatures, actualFilledTakerAmount
);
// Restore original timestamp
vm.warp(currentTimestamp);
vm.stopPrank();
// NOTE: END SETUP FOR TESTING
// Calculate actual amount received
uint256 balanceAfter = tokenOut == address(0)
? order.receiver.balance
: IERC20(tokenOut).balanceOf(order.receiver);
amountOut = balanceAfter - balanceBefore;
}
}
@@ -262,9 +299,6 @@ contract BebopExecutorTest is Constants, Permit2TestHelper, TestUtils {
// Fork will be created in individual tests to allow different fork blocks
}
// Allow test contract to receive ETH
receive() external payable {}
function testDecodeParams() public {
// Fork to ensure consistent setup
vm.createSelectFork(vm.rpcUrl("mainnet"), 22667985);
@@ -542,7 +576,286 @@ contract BebopExecutorTest is Constants, Permit2TestHelper, TestUtils {
// Aggregate Order Tests
function testAggregateOrder() public {
vm.skip(true);
// Fork at a suitable block for aggregate order testing
vm.createSelectFork(vm.rpcUrl("mainnet"), 21370890);
// Deploy Bebop executor harness that uses vm.prank
bebopExecutor =
new BebopExecutorHarness(BEBOP_SETTLEMENT, PERMIT2_ADDRESS);
// Store the initial ETH balance (dust from forked state)
uint256 initialExecutorBalance = address(bebopExecutor).balance;
// Create test data from real mainnet transaction
// https://etherscan.io/tx/0xec88410136c287280da87d0a37c1cb745f320406ca3ae55c678dec11996c1b1c
address originalTakerAddress =
0x7078B12Ca5B294d95e9aC16D90B7D38238d8F4E6;
// Create the 2D arrays for tokens and amounts
address[][] memory takerTokens = new address[][](2);
takerTokens[0] = new address[](1);
takerTokens[0][0] = WETH_ADDR; // WETH for first maker
takerTokens[1] = new address[](1);
takerTokens[1][0] = WETH_ADDR; // WETH for second maker
address[][] memory makerTokens = new address[][](2);
makerTokens[0] = new address[](1);
makerTokens[0][0] = USDC_ADDR; // USDC from first maker
makerTokens[1] = new address[](1);
makerTokens[1][0] = USDC_ADDR; // USDC from second maker
uint256[][] memory takerAmounts = new uint256[][](2);
takerAmounts[0] = new uint256[](1);
takerAmounts[0][0] = 5812106401997138; // First maker takes ~0.0058 ETH
takerAmounts[1] = new uint256[](1);
takerAmounts[1][0] = 4037893598002862; // Second maker takes ~0.0040 ETH
uint256[][] memory makerAmounts = new uint256[][](2);
makerAmounts[0] = new uint256[](1);
makerAmounts[0][0] = 10607211; // First maker gives ~10.6 USDC
makerAmounts[1] = new uint256[](1);
makerAmounts[1][0] = 7362350; // Second maker gives ~7.36 USDC
// Create makers array
address[] memory makerAddresses = new address[](2);
makerAddresses[0] = 0x67336Cec42645F55059EfF241Cb02eA5cC52fF86;
makerAddresses[1] = 0xBF19CbF0256f19f39A016a86Ff3551ecC6f2aAFE;
// Create maker nonces array
uint256[] memory makerNonces = new uint256[](2);
makerNonces[0] = 1746367197308;
makerNonces[1] = 15460096;
// Create the aggregate order
IBebopSettlement.Aggregate memory order = IBebopSettlement.Aggregate({
expiry: 1746367285,
taker_address: originalTakerAddress,
maker_addresses: makerAddresses,
maker_nonces: makerNonces,
taker_tokens: takerTokens,
maker_tokens: makerTokens,
taker_amounts: takerAmounts,
maker_amounts: makerAmounts,
receiver: originalTakerAddress,
commands: hex"00040004",
flags: 95769172144825922628485191511070792431742484643425438763224908097896054784000
});
// Total amounts
uint256 totalTakerAmount = takerAmounts[0][0] + takerAmounts[1][0]; // 0.00985 ETH total
uint256 totalMakerAmount = makerAmounts[0][0] + makerAmounts[1][0]; // 17.969561 USDC total
// Fund makers with USDC and approve settlement
deal(USDC_ADDR, makerAddresses[0], makerAmounts[0][0]);
deal(USDC_ADDR, makerAddresses[1], makerAmounts[1][0]);
vm.prank(makerAddresses[0]);
USDC.approve(BEBOP_SETTLEMENT, makerAmounts[0][0]);
vm.prank(makerAddresses[1]);
USDC.approve(BEBOP_SETTLEMENT, makerAmounts[1][0]);
// ETH will be sent directly with the swap call
// Fund the test contract with ETH to send with the swap
vm.deal(address(this), totalTakerAmount);
// Record initial balances
uint256 usdcBefore = USDC.balanceOf(originalTakerAddress);
// Create maker signatures
IBebopSettlement.MakerSignature[] memory signatures =
new IBebopSettlement.MakerSignature[](2);
signatures[0] = IBebopSettlement.MakerSignature({
signatureBytes: hex"d5abb425f9bac1f44d48705f41a8ab9cae207517be8553d2c03b06a88995f2f351ab8ce7627a87048178d539dd64fd2380245531a0c8e43fdc614652b1f32fc71c",
flags: 0 // ETH_SIGN
});
signatures[1] = IBebopSettlement.MakerSignature({
signatureBytes: hex"f38c698e48a3eac48f184bc324fef0b135ee13705ab38cc0bbf5a792f21002f051e445b9e7d57cf24c35e17629ea35b3263591c4abf8ca87ffa44b41301b89c41b",
flags: 0 // ETH_SIGN
});
// Encode order and signatures
bytes memory quoteData = abi.encode(order);
bytes memory makerSignaturesData = abi.encode(signatures);
// Create packed params for executor with native ETH as input
bytes memory params = abi.encodePacked(
address(0), // tokenIn: native ETH
USDC_ADDR, // tokenOut
uint8(RestrictTransferFrom.TransferType.Transfer),
uint8(BebopExecutor.OrderType.Aggregate),
uint256(0), // filledTakerAmount: 0 for full fill
uint32(quoteData.length),
quoteData,
uint32(makerSignaturesData.length),
makerSignaturesData,
uint8(0) // approvalNeeded: false for native ETH
);
// Execute the aggregate swap with ETH value
uint256 amountOut = bebopExecutor.swap{value: totalTakerAmount}(
totalTakerAmount, params
);
// Verify results
assertEq(amountOut, totalMakerAmount, "Incorrect amount out");
assertEq(
USDC.balanceOf(originalTakerAddress) - usdcBefore,
totalMakerAmount,
"USDC balance mismatch"
);
assertEq(
USDC.balanceOf(address(bebopExecutor)), 0, "USDC left in executor"
);
assertEq(
address(bebopExecutor).balance,
initialExecutorBalance,
"ETH left in executor should match initial dust amount"
);
}
function testAggregateOrder_PartialFill() public {
// Fork at a suitable block for aggregate order testing
vm.createSelectFork(vm.rpcUrl("mainnet"), 21370890);
// Deploy Bebop executor harness that uses vm.prank
bebopExecutor =
new BebopExecutorHarness(BEBOP_SETTLEMENT, PERMIT2_ADDRESS);
// Store the initial ETH balance (dust from forked state)
uint256 initialExecutorBalance = address(bebopExecutor).balance;
// Same aggregate order as before, but with partial fill
address originalTakerAddress =
0x7078B12Ca5B294d95e9aC16D90B7D38238d8F4E6;
// Create the 2D arrays for tokens and amounts
address[][] memory takerTokens = new address[][](2);
takerTokens[0] = new address[](1);
takerTokens[0][0] = WETH_ADDR;
takerTokens[1] = new address[](1);
takerTokens[1][0] = WETH_ADDR;
address[][] memory makerTokens = new address[][](2);
makerTokens[0] = new address[](1);
makerTokens[0][0] = USDC_ADDR;
makerTokens[1] = new address[](1);
makerTokens[1][0] = USDC_ADDR;
uint256[][] memory takerAmounts = new uint256[][](2);
takerAmounts[0] = new uint256[](1);
takerAmounts[0][0] = 5812106401997138;
takerAmounts[1] = new uint256[](1);
takerAmounts[1][0] = 4037893598002862;
uint256[][] memory makerAmounts = new uint256[][](2);
makerAmounts[0] = new uint256[](1);
makerAmounts[0][0] = 10607211;
makerAmounts[1] = new uint256[](1);
makerAmounts[1][0] = 7362350;
// Create makers array
address[] memory makerAddresses = new address[](2);
makerAddresses[0] = 0x67336Cec42645F55059EfF241Cb02eA5cC52fF86;
makerAddresses[1] = 0xBF19CbF0256f19f39A016a86Ff3551ecC6f2aAFE;
// Create maker nonces array
uint256[] memory makerNonces = new uint256[](2);
makerNonces[0] = 1746367197308;
makerNonces[1] = 15460096;
// Create the aggregate order
IBebopSettlement.Aggregate memory order = IBebopSettlement.Aggregate({
expiry: 1746367285,
taker_address: originalTakerAddress,
maker_addresses: makerAddresses,
maker_nonces: makerNonces,
taker_tokens: takerTokens,
maker_tokens: makerTokens,
taker_amounts: takerAmounts,
maker_amounts: makerAmounts,
receiver: originalTakerAddress,
commands: hex"00040004",
flags: 95769172144825922628485191511070792431742484643425438763224908097896054784000
});
// Total amounts
uint256 totalTakerAmount = takerAmounts[0][0] + takerAmounts[1][0];
uint256 totalMakerAmount = makerAmounts[0][0] + makerAmounts[1][0];
// We'll do a 50% partial fill
uint256 partialFillAmount = totalTakerAmount / 2;
uint256 expectedPartialOutput = totalMakerAmount / 2;
// Fund makers with FULL amounts (they need enough for any partial fill)
deal(USDC_ADDR, makerAddresses[0], makerAmounts[0][0]);
deal(USDC_ADDR, makerAddresses[1], makerAmounts[1][0]);
vm.prank(makerAddresses[0]);
USDC.approve(BEBOP_SETTLEMENT, makerAmounts[0][0]);
vm.prank(makerAddresses[1]);
USDC.approve(BEBOP_SETTLEMENT, makerAmounts[1][0]);
// ETH will be sent directly with the swap call
// Fund the test contract with ETH to send with the swap
vm.deal(address(this), partialFillAmount);
// Record initial balances
uint256 usdcBefore = USDC.balanceOf(originalTakerAddress);
// Create maker signatures
IBebopSettlement.MakerSignature[] memory signatures =
new IBebopSettlement.MakerSignature[](2);
signatures[0] = IBebopSettlement.MakerSignature({
signatureBytes: hex"d5abb425f9bac1f44d48705f41a8ab9cae207517be8553d2c03b06a88995f2f351ab8ce7627a87048178d539dd64fd2380245531a0c8e43fdc614652b1f32fc71c",
flags: 0
});
signatures[1] = IBebopSettlement.MakerSignature({
signatureBytes: hex"f38c698e48a3eac48f184bc324fef0b135ee13705ab38cc0bbf5a792f21002f051e445b9e7d57cf24c35e17629ea35b3263591c4abf8ca87ffa44b41301b89c41b",
flags: 0
});
// Encode order and signatures
bytes memory quoteData = abi.encode(order);
bytes memory makerSignaturesData = abi.encode(signatures);
// Create packed params for executor with partial fill amount
bytes memory params = abi.encodePacked(
address(0), // tokenIn: native ETH
USDC_ADDR,
uint8(RestrictTransferFrom.TransferType.Transfer),
uint8(BebopExecutor.OrderType.Aggregate),
partialFillAmount, // Specify partial fill amount
uint32(quoteData.length),
quoteData,
uint32(makerSignaturesData.length),
makerSignaturesData,
uint8(0) // approvalNeeded: false for native ETH
);
// Execute the partial aggregate swap with ETH value
uint256 amountOut = bebopExecutor.swap{value: partialFillAmount}(
partialFillAmount, params
);
// Verify results - should be proportional to the partial fill
assertEq(
amountOut, expectedPartialOutput, "Incorrect partial amount out"
);
assertEq(
USDC.balanceOf(originalTakerAddress) - usdcBefore,
expectedPartialOutput,
"USDC balance mismatch for partial fill"
);
assertEq(
USDC.balanceOf(address(bebopExecutor)), 0, "USDC left in executor"
);
assertEq(
address(bebopExecutor).balance,
initialExecutorBalance,
"ETH left in executor should match initial dust amount"
);
}
function testInvalidDataLength() public {
@@ -599,4 +912,114 @@ contract BebopExecutorTest is Constants, Permit2TestHelper, TestUtils {
vm.expectRevert(BebopExecutor.BebopExecutor__InvalidDataLength.selector);
bebopExecutor.decodeParams(tooShortParams);
}
// Integration tests
function testSwapSingleIntegration() public {
// Fork at the right block first
vm.createSelectFork(vm.rpcUrl("mainnet"), 22667985);
// Deploy Bebop executor harness
bebopExecutor =
new BebopExecutorHarness(BEBOP_SETTLEMENT, PERMIT2_ADDRESS);
// Load encoded data from test_encode_bebop_single (USDC → ONDO swap)
bytes memory protocolData =
loadCallDataFromFile("test_encode_bebop_single");
// Deal 200 USDC to the executor
uint256 amountIn = 200000000; // 200 USDC
deal(USDC_ADDR, address(bebopExecutor), amountIn);
// Fund the maker with ONDO and approve settlement
address maker = 0xCe79b081c0c924cb67848723ed3057234d10FC6b;
uint256 expectedAmountOut = 237212396774431060000; // 237.21 ONDO
deal(ONDO_ADDR, maker, expectedAmountOut);
vm.prank(maker);
ONDO.approve(BEBOP_SETTLEMENT, expectedAmountOut);
// Record receiver's initial ONDO balance
address receiver = 0xc5564C13A157E6240659fb81882A28091add8670;
uint256 ondoBefore = ONDO.balanceOf(receiver);
// Execute the swap
uint256 amountOut = bebopExecutor.swap(amountIn, protocolData);
// Verify results
assertEq(amountOut, expectedAmountOut, "Incorrect amount out");
assertEq(
ONDO.balanceOf(receiver) - ondoBefore,
expectedAmountOut,
"ONDO balance mismatch"
);
assertEq(
USDC.balanceOf(address(bebopExecutor)), 0, "USDC left in executor"
);
assertEq(
ONDO.balanceOf(address(bebopExecutor)), 0, "ONDO left in executor"
);
}
function testSwapAggregateIntegration() public {
// Fork at a suitable block for aggregate order testing
vm.createSelectFork(vm.rpcUrl("mainnet"), 21370890);
// Deploy Bebop executor harness
bebopExecutor =
new BebopExecutorHarness(BEBOP_SETTLEMENT, PERMIT2_ADDRESS);
// Store the initial ETH balance (dust from forked state)
uint256 initialExecutorBalance = address(bebopExecutor).balance;
// Based on real transaction: https://etherscan.io/tx/0xec88410136c287280da87d0a37c1cb745f320406ca3ae55c678dec11996c1b1c
address orderTaker = 0x7078B12Ca5B294d95e9aC16D90B7D38238d8F4E6; // This is both taker and receiver in the order
uint256 ethAmount = 9850000000000000; // 0.00985 WETH
uint256 expAmountOut = 17969561; // 17.969561 USDC expected output
// Fund the two makers from the real transaction with USDC
address maker1 = 0x67336Cec42645F55059EfF241Cb02eA5cC52fF86;
address maker2 = 0xBF19CbF0256f19f39A016a86Ff3551ecC6f2aAFE;
deal(USDC_ADDR, maker1, 10607211); // Maker 1 provides 10.607211 USDC
deal(USDC_ADDR, maker2, 7362350); // Maker 2 provides 7.362350 USDC
// Makers approve settlement contract
vm.prank(maker1);
IERC20(USDC_ADDR).approve(BEBOP_SETTLEMENT, type(uint256).max);
vm.prank(maker2);
IERC20(USDC_ADDR).approve(BEBOP_SETTLEMENT, type(uint256).max);
// Fund ALICE with ETH as it will send the transaction
vm.deal(ALICE, ethAmount);
vm.startPrank(ALICE);
// Load encoded data from test_encode_bebop_aggregate (ETH → USDC multi-maker swap)
bytes memory protocolData =
loadCallDataFromFile("test_encode_bebop_aggregate");
// Record initial USDC balance
uint256 usdcBefore = IERC20(USDC_ADDR).balanceOf(orderTaker);
// Execute the swap with native ETH
uint256 amountOut =
bebopExecutor.swap{value: ethAmount}(ethAmount, protocolData);
// Verify results
assertEq(amountOut, expAmountOut, "Incorrect amount out");
assertEq(
IERC20(USDC_ADDR).balanceOf(orderTaker) - usdcBefore,
expAmountOut,
"USDC balance mismatch"
);
assertEq(
IERC20(USDC_ADDR).balanceOf(address(bebopExecutor)),
0,
"USDC left in executor"
);
assertEq(
address(bebopExecutor).balance,
initialExecutorBalance,
"ETH left in executor should match initial dust amount"
);
vm.stopPrank();
}
}