chore: fix extract_aggregate_taker_amount and bebop unit tests
This commit is contained in:
pedrobergamini
@@ -669,79 +669,115 @@ impl BebopSwapEncoder {
|
||||
}
|
||||
|
||||
/// Extract the total taker amount from a Bebop aggregate order calldata
|
||||
/// This is required because BebopExecutor needs a non-zero filledTakerAmount
|
||||
fn extract_aggregate_taker_amount(bebop_calldata: &[u8]) -> Option<U256> {
|
||||
// Minimum size check: 4 (selector) + 32 (order offset) + 32 (signatures offset) + 32
|
||||
// (filledTakerAmount) = 100 bytes This ensures we can safely read the offset to the order
|
||||
// parameter
|
||||
// (filledTakerAmount) = 100 bytes
|
||||
if bebop_calldata.len() < 100 {
|
||||
return None;
|
||||
}
|
||||
|
||||
// Read the offset to the order struct (first parameter)
|
||||
let order_offset = U256::from_be_slice(&bebop_calldata[4..36]).to::<usize>() + 4;
|
||||
// The order offset is at bytes 4-36 (after selector)
|
||||
let order_offset_value = U256::from_be_slice(&bebop_calldata[4..36]);
|
||||
// Add 4 to account for the selector when calculating absolute position
|
||||
let order_offset = order_offset_value.to::<usize>() + 4;
|
||||
|
||||
// The Aggregate struct fields (all offsets are relative to the start of the struct):
|
||||
// 0: expiry (32 bytes)
|
||||
// 1: taker_address (32 bytes)
|
||||
// 2: offset to maker_addresses array (32 bytes)
|
||||
// 3: offset to maker_nonces array (32 bytes)
|
||||
// 4: offset to taker_tokens array (32 bytes)
|
||||
// 5: offset to maker_tokens array (32 bytes)
|
||||
// 6: offset to taker_amounts array (32 bytes) <- we need this
|
||||
// The Aggregate struct has 11 fields:
|
||||
// 0: expiry (U256) - at order_offset + 0
|
||||
// 1: taker_address (address) - at order_offset + 32
|
||||
// 2: maker_addresses (address[]) - offset at order_offset + 64
|
||||
// 3: maker_nonces (uint256[]) - offset at order_offset + 96
|
||||
// 4: taker_tokens (address[][]) - offset at order_offset + 128
|
||||
// 5: maker_tokens (address[][]) - offset at order_offset + 160
|
||||
// 6: taker_amounts (uint256[][]) - offset at order_offset + 192 <- we need this
|
||||
// 7: maker_amounts (uint256[][]) - offset at order_offset + 224
|
||||
// 8: receiver (address) - at order_offset + 256
|
||||
// 9: commands (bytes) - offset at order_offset + 288
|
||||
// 10: flags (uint256) - at order_offset + 320
|
||||
|
||||
// Make sure we can read the taker_amounts offset
|
||||
if bebop_calldata.len() <= order_offset + 224 {
|
||||
return None;
|
||||
}
|
||||
|
||||
// Read the offset to taker_amounts (relative to the start of the order struct)
|
||||
let taker_amounts_offset =
|
||||
U256::from_be_slice(&bebop_calldata[order_offset + 192..order_offset + 224]).to::<usize>();
|
||||
|
||||
// Calculate absolute position of taker_amounts data
|
||||
let taker_amounts_data_offset = order_offset + taker_amounts_offset;
|
||||
|
||||
// Read the taker_amounts 2D array
|
||||
// Make sure we can read the array length
|
||||
if bebop_calldata.len() <= taker_amounts_data_offset + 32 {
|
||||
return None;
|
||||
}
|
||||
|
||||
// First 32 bytes is the array length (number of makers)
|
||||
// Read the number of makers (outer array length)
|
||||
let num_makers = U256::from_be_slice(
|
||||
&bebop_calldata[taker_amounts_data_offset..taker_amounts_data_offset + 32],
|
||||
)
|
||||
.to::<usize>();
|
||||
);
|
||||
|
||||
let total_taker_amount = (0..num_makers)
|
||||
// turn each maker-offset word into an absolute data offset
|
||||
.filter_map(|idx| {
|
||||
let word_start = taker_amounts_data_offset + 32 + idx * 32;
|
||||
if bebop_calldata.len() <= word_start + 32 {
|
||||
// Sanity check
|
||||
if num_makers == U256::ZERO || num_makers > U256::from(100) {
|
||||
return None;
|
||||
}
|
||||
|
||||
let num_makers = num_makers.to::<usize>();
|
||||
|
||||
// Now we need to read the 2D array structure
|
||||
// After the array length, we have num_makers offsets (each 32 bytes)
|
||||
// Each offset points to that maker's taker_amounts array
|
||||
|
||||
let mut total = U256::ZERO;
|
||||
|
||||
for maker_idx in 0..num_makers {
|
||||
// Read the offset to this maker's taker_amounts array
|
||||
let offset_position = taker_amounts_data_offset + 32 + (maker_idx * 32);
|
||||
|
||||
if bebop_calldata.len() <= offset_position + 32 {
|
||||
return None;
|
||||
}
|
||||
|
||||
// This offset is relative to the start of the taker_amounts array
|
||||
let maker_array_offset =
|
||||
U256::from_be_slice(&bebop_calldata[offset_position..offset_position + 32])
|
||||
.to::<usize>();
|
||||
|
||||
// Calculate absolute position of this maker's array
|
||||
let maker_array_position = taker_amounts_data_offset + maker_array_offset;
|
||||
|
||||
// Read the length of this maker's taker_amounts array
|
||||
if bebop_calldata.len() <= maker_array_position + 32 {
|
||||
return None;
|
||||
}
|
||||
|
||||
let num_amounts =
|
||||
U256::from_be_slice(&bebop_calldata[maker_array_position..maker_array_position + 32])
|
||||
.to::<usize>();
|
||||
|
||||
// Sanity check
|
||||
if num_amounts > 100 {
|
||||
return None;
|
||||
}
|
||||
|
||||
// Sum all amounts for this maker
|
||||
for amount_idx in 0..num_amounts {
|
||||
let amount_position = maker_array_position + 32 + (amount_idx * 32);
|
||||
|
||||
if bebop_calldata.len() <= amount_position + 32 {
|
||||
return None;
|
||||
}
|
||||
let rel =
|
||||
U256::from_be_slice(&bebop_calldata[word_start..word_start + 32]).to::<usize>();
|
||||
Some(taker_amounts_data_offset + rel)
|
||||
})
|
||||
// for every maker, accumulate its taker_amounts array
|
||||
.map(|maker_data_off| {
|
||||
if bebop_calldata.len() <= maker_data_off + 32 {
|
||||
return U256::ZERO;
|
||||
}
|
||||
let num_amounts =
|
||||
U256::from_be_slice(&bebop_calldata[maker_data_off..maker_data_off + 32])
|
||||
.to::<usize>();
|
||||
|
||||
(0..num_amounts)
|
||||
.filter_map(|j| {
|
||||
let amount_off = maker_data_off + 32 + j * 32;
|
||||
if bebop_calldata.len() < amount_off + 32 {
|
||||
return None;
|
||||
}
|
||||
Some(U256::from_be_slice(&bebop_calldata[amount_off..amount_off + 32]))
|
||||
})
|
||||
.fold(U256::ZERO, |acc, amt| acc.saturating_add(amt))
|
||||
})
|
||||
.fold(U256::ZERO, |acc, maker_sum| acc.saturating_add(maker_sum));
|
||||
let amount =
|
||||
U256::from_be_slice(&bebop_calldata[amount_position..amount_position + 32]);
|
||||
|
||||
if total_taker_amount > U256::ZERO {
|
||||
Some(total_taker_amount)
|
||||
total = total.saturating_add(amount);
|
||||
}
|
||||
}
|
||||
|
||||
if total > U256::ZERO {
|
||||
Some(total)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
@@ -817,57 +853,97 @@ impl SwapEncoder for BebopSwapEncoder {
|
||||
// The calldata should be for either swapSingle or swapAggregate
|
||||
let bebop_calldata = user_data[1..].to_vec();
|
||||
|
||||
// Extract the original filledTakerAmount from the calldata
|
||||
// Both swapSingle and swapAggregate have filledTakerAmount as the last parameter
|
||||
// We need at least 4 bytes selector + 32 bytes for filledTakerAmount at the end
|
||||
if bebop_calldata.len() < 36 {
|
||||
return Err(EncodingError::InvalidInput(
|
||||
"Bebop calldata too short to contain filledTakerAmount".to_string(),
|
||||
));
|
||||
// Extract the original filledTakerAmount from the calldata using partialFillOffset
|
||||
// The actual byte position is 4 (selector) + partialFillOffset * 32
|
||||
let filled_taker_amount_pos = 4 + (partial_fill_offset as usize) * 32;
|
||||
|
||||
// Ensure the calldata is long enough to contain filledTakerAmount at the calculated
|
||||
// position
|
||||
if bebop_calldata.len() < filled_taker_amount_pos + 32 {
|
||||
return Err(EncodingError::InvalidInput(format!(
|
||||
"Bebop calldata too short to contain filledTakerAmount at offset {}",
|
||||
partial_fill_offset
|
||||
)));
|
||||
}
|
||||
|
||||
// Extract the original filledTakerAmount, using the order's taker_amount if it's zero
|
||||
let original_filled_taker_amount = {
|
||||
let filled_amount = U256::from_be_slice(&bebop_calldata[bebop_calldata.len() - 32..]);
|
||||
// Extract the original filledTakerAmount and receiver from the order
|
||||
let (original_filled_taker_amount, receiver) = {
|
||||
let filled_taker_amount = U256::from_be_slice(
|
||||
&bebop_calldata[filled_taker_amount_pos..filled_taker_amount_pos + 32],
|
||||
);
|
||||
|
||||
if filled_amount != U256::ZERO {
|
||||
filled_amount
|
||||
} else {
|
||||
// Extract taker_amount from the order based on the function selector
|
||||
let selector = &bebop_calldata[0..4];
|
||||
// Extract receiver and taker_amount from the order based on the function selector
|
||||
let selector = &bebop_calldata[0..4];
|
||||
|
||||
// swapSingle selector: 0x4dcebcba
|
||||
// swapAggregate selector: 0xa2f74893
|
||||
const SWAP_SINGLE_SELECTOR: [u8; 4] = [0x4d, 0xce, 0xbc, 0xba];
|
||||
const SWAP_AGGREGATE_SELECTOR: [u8; 4] = [0xa2, 0xf7, 0x48, 0x93];
|
||||
// swapSingle selector: 0x4dcebcba
|
||||
// swapAggregate selector: 0xa2f74893
|
||||
const SWAP_SINGLE_SELECTOR: [u8; 4] = [0x4d, 0xce, 0xbc, 0xba];
|
||||
const SWAP_AGGREGATE_SELECTOR: [u8; 4] = [0xa2, 0xf7, 0x48, 0x93];
|
||||
|
||||
if selector == SWAP_SINGLE_SELECTOR {
|
||||
// For swapSingle, decode the Single struct to get taker_amount
|
||||
// The Single struct is the first parameter after the selector
|
||||
// Single struct has fields in order: expiry, taker_address, maker_address,
|
||||
// maker_nonce, taker_token, maker_token, taker_amount, maker_amount, etc.
|
||||
// taker_amount is at position 6 (0-indexed), so offset is 4 + 32*6 = 196
|
||||
if bebop_calldata.len() >= 228 {
|
||||
U256::from_be_slice(&bebop_calldata[196..228])
|
||||
if selector == SWAP_SINGLE_SELECTOR {
|
||||
// For swapSingle, decode the Single struct
|
||||
// Single struct layout (after selector at offset 4):
|
||||
// 0: offset to order (32 bytes) -> points to 96 (0x60)
|
||||
// 32: offset to signature (32 bytes)
|
||||
// 64: filledTakerAmount (32 bytes)
|
||||
// 96: order struct starts here:
|
||||
// - expiry (32)
|
||||
// - taker_address (32)
|
||||
// - maker_address (32)
|
||||
// - maker_nonce (32)
|
||||
// - taker_token (32)
|
||||
// - maker_token (32)
|
||||
// - taker_amount (32)
|
||||
// - maker_amount (32)
|
||||
// - receiver (32)
|
||||
// So receiver is at: 4 + 96 + 256 = 356
|
||||
if bebop_calldata.len() >= 388 {
|
||||
let taker_amount = if filled_taker_amount != U256::ZERO {
|
||||
filled_taker_amount
|
||||
} else {
|
||||
U256::ZERO
|
||||
}
|
||||
} else if selector == SWAP_AGGREGATE_SELECTOR {
|
||||
// For swapAggregate, we need to sum all taker_amounts
|
||||
// The calldata structure is: selector(4) + offset_to_order(32) +
|
||||
// offset_to_signatures(32) + filledTakerAmount(32) + order_data +
|
||||
// signatures_data
|
||||
extract_aggregate_taker_amount(&bebop_calldata).unwrap_or(U256::ZERO)
|
||||
// taker_amount is at: 4 + 96 + 192 = 292
|
||||
U256::from_be_slice(&bebop_calldata[292..324])
|
||||
};
|
||||
// receiver is at: 4 + 96 + 256 = 356 (take 20 bytes, skip 12 padding)
|
||||
let receiver_bytes = &bebop_calldata[368..388];
|
||||
let receiver = Address::from_slice(receiver_bytes);
|
||||
(taker_amount, receiver)
|
||||
} else {
|
||||
U256::ZERO
|
||||
(U256::ZERO, Address::ZERO)
|
||||
}
|
||||
} else if selector == SWAP_AGGREGATE_SELECTOR {
|
||||
// For swapAggregate, extract receiver from the aggregate order
|
||||
// The order starts after: selector(4) + offset_to_order(32) +
|
||||
// offset_to_signatures(32) + filledTakerAmount(32) = 100
|
||||
// Then we have the order struct with dynamic arrays
|
||||
// We need to carefully parse to find the receiver field
|
||||
// Since receiver comes after all the dynamic arrays, it's complex to calculate its
|
||||
// exact position For now, we'll use a simplified approach since the
|
||||
// exact receiver extraction for aggregates requires full ABI decoding
|
||||
|
||||
// For aggregate orders, if filled_taker_amount is 0, we need to calculate the total
|
||||
// from the order data because BebopExecutor requires a non-zero value
|
||||
let taker_amount = if filled_taker_amount != U256::ZERO {
|
||||
filled_taker_amount
|
||||
} else {
|
||||
// Extract and sum all taker amounts from the aggregate order
|
||||
extract_aggregate_taker_amount(&bebop_calldata).unwrap_or(U256::ZERO)
|
||||
};
|
||||
|
||||
// For aggregate orders, extract receiver (this is a simplified extraction)
|
||||
// In real implementation, we'd need proper ABI decoding for the complex nested
|
||||
// structure For now, use zero address as fallback - this will be
|
||||
// handled properly in production
|
||||
(taker_amount, Address::ZERO)
|
||||
} else {
|
||||
(U256::ZERO, Address::ZERO)
|
||||
}
|
||||
};
|
||||
|
||||
// Encode packed data for the executor
|
||||
// Format: token_in | token_out | transfer_type | bebop_calldata_length |
|
||||
// bebop_calldata | partial_fill_offset | original_filled_taker_amount |
|
||||
// approval_needed
|
||||
// approval_needed | receiver
|
||||
let args = (
|
||||
token_in,
|
||||
token_out,
|
||||
@@ -877,6 +953,7 @@ impl SwapEncoder for BebopSwapEncoder {
|
||||
partial_fill_offset.to_be_bytes(),
|
||||
original_filled_taker_amount.to_be_bytes::<32>(),
|
||||
(approval_needed as u8).to_be_bytes(),
|
||||
receiver,
|
||||
);
|
||||
|
||||
Ok(args.abi_encode_packed())
|
||||
@@ -1947,20 +2024,87 @@ mod tests {
|
||||
use crate::encoding::{evm::utils::write_calldata_to_file, models::TransferType};
|
||||
|
||||
#[test]
|
||||
fn test_encode_bebop_calldata_forwarding() {
|
||||
use alloy::hex;
|
||||
fn test_encode_bebop_single() {
|
||||
use alloy::{hex, primitives::Address, sol_types::SolValue};
|
||||
|
||||
// Create mock Bebop calldata for swapSingle
|
||||
// This would normally come from the Bebop API response
|
||||
let bebop_calldata = hex::decode(
|
||||
"47fb5891".to_owned() // swapSingle selector
|
||||
+ "0000000000000000000000000000000000000000000000000000000000000001" // mock order data
|
||||
+ "0000000000000000000000000000000000000000000000000000000000000002" // mock signature data
|
||||
+ "0000000000000000000000000000000000000000000000000000000bebc200" // filledTakerAmount = 200000000
|
||||
).unwrap();
|
||||
// Transaction: https://etherscan.io/tx/0x6279bc970273b6e526e86d9b69133c2ca1277e697ba25375f5e6fc4df50c0c94
|
||||
let expiry = 1749483840u64;
|
||||
let taker_address = Address::from_slice(
|
||||
&hex::decode("c5564C13A157E6240659fb81882A28091add8670").unwrap(),
|
||||
);
|
||||
let maker_address = Address::from_slice(
|
||||
&hex::decode("Ce79b081c0c924cb67848723ed3057234d10FC6b").unwrap(),
|
||||
);
|
||||
let maker_nonce = 1749483765992417u64;
|
||||
let taker_token = Address::from_slice(
|
||||
&hex::decode("A0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48").unwrap(),
|
||||
); // USDC
|
||||
let maker_token = Address::from_slice(
|
||||
&hex::decode("fAbA6f8e4a5E8Ab82F62fe7C39859FA577269BE3").unwrap(),
|
||||
); // ONDO
|
||||
let taker_amount = U256::from(200000000u64); // 200 USDC
|
||||
let maker_amount = U256::from_str_radix("cd97e88ccc64d54000", 16).unwrap(); // 237.21 ONDO
|
||||
let receiver = taker_address;
|
||||
let packed_commands = U256::ZERO;
|
||||
let flags = U256::from_str_radix(
|
||||
"727220e0ad42bc02077c9bb3a3d60c41bfd3df1a80f5e97aa87e3ea6e93a0000",
|
||||
16,
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
// Encode the order struct using ABI encoding
|
||||
let quote_data = (
|
||||
expiry,
|
||||
taker_address,
|
||||
maker_address,
|
||||
maker_nonce,
|
||||
taker_token,
|
||||
maker_token,
|
||||
taker_amount,
|
||||
maker_amount,
|
||||
receiver,
|
||||
packed_commands,
|
||||
flags,
|
||||
)
|
||||
.abi_encode();
|
||||
|
||||
// Real signature from mainnet
|
||||
let signature = hex::decode("eb5419631614978da217532a40f02a8f2ece37d8cfb94aaa602baabbdefb56b474f4c2048a0f56502caff4ea7411d99eed6027cd67dc1088aaf4181dcb0df7051c").unwrap();
|
||||
|
||||
// Build the complete swapSingle calldata
|
||||
let mut bebop_calldata = Vec::new();
|
||||
|
||||
// swapSingle selector
|
||||
bebop_calldata.extend_from_slice(&[0x4d, 0xce, 0xbc, 0xba]);
|
||||
|
||||
// Encode parameters: (Single order, MakerSignature signature, uint256
|
||||
// filledTakerAmount) Calculate offsets (relative to start of params, not
|
||||
// selector)
|
||||
let order_offset = U256::from(96); // After 3 words (2 offsets + filledTakerAmount)
|
||||
let signature_offset = U256::from(96 + quote_data.len());
|
||||
|
||||
// Write the three parameter slots
|
||||
bebop_calldata.extend_from_slice(&order_offset.to_be_bytes::<32>());
|
||||
bebop_calldata.extend_from_slice(&signature_offset.to_be_bytes::<32>());
|
||||
bebop_calldata.extend_from_slice(&taker_amount.to_be_bytes::<32>()); // filledTakerAmount = taker_amount for full fill
|
||||
|
||||
// Append order data (already encoded)
|
||||
bebop_calldata.extend_from_slice("e_data);
|
||||
|
||||
// Encode MakerSignature struct
|
||||
// Offset to signatureBytes (always 64 for this struct layout)
|
||||
bebop_calldata.extend_from_slice(&U256::from(64).to_be_bytes::<32>());
|
||||
// Flags (0 for ETH_SIGN)
|
||||
bebop_calldata.extend_from_slice(&U256::ZERO.to_be_bytes::<32>());
|
||||
// SignatureBytes (length + data)
|
||||
bebop_calldata.extend_from_slice(&U256::from(signature.len()).to_be_bytes::<32>());
|
||||
bebop_calldata.extend_from_slice(&signature);
|
||||
// Pad to 32-byte boundary
|
||||
let padding = (32 - (signature.len() % 32)) % 32;
|
||||
bebop_calldata.extend(vec![0u8; padding]);
|
||||
|
||||
// Prepend the partialFillOffset (12 for swapSingle)
|
||||
let mut user_data = vec![12u8]; // partialFillOffset = 12
|
||||
let mut user_data = vec![12u8];
|
||||
user_data.extend_from_slice(&bebop_calldata);
|
||||
|
||||
let bebop_component = ProtocolComponent {
|
||||
@@ -2010,7 +2154,7 @@ mod tests {
|
||||
assert!(hex_swap.contains("faba6f8e4a5e8ab82f62fe7c39859fa577269be3")); // ONDO
|
||||
|
||||
// Verify it includes the bebop calldata
|
||||
let calldata_hex = hex::encode(&bebop_calldata);
|
||||
let calldata_hex = hex::encode(bebop_calldata);
|
||||
assert!(hex_swap.contains(&calldata_hex));
|
||||
|
||||
// Verify the original amount matches the filledTakerAmount from calldata
|
||||
@@ -2018,29 +2162,145 @@ mod tests {
|
||||
hex_swap.contains("0000000000000000000000000000000000000000000000000000000bebc200")
|
||||
); // 200000000 in hex
|
||||
|
||||
// Verify the partialFillOffset byte appears after the bebop calldata
|
||||
// Look for the pattern: end of bebop calldata (bebc200) followed by offset (0c)
|
||||
assert!(hex_swap.contains("bebc2000c")); // filledTakerAmount followed by offset byte
|
||||
// Verify the partialFillOffset byte (0c = 12) appears in the right place
|
||||
// The packed data format is: tokens | transfer_type | bebop_calldata_length |
|
||||
// bebop_calldata | partialFillOffset | original_filled_taker_amount | approval_needed |
|
||||
// receiver Looking at the hex output, we can see that partialFillOffset
|
||||
// (0c) is followed by the original filledTakerAmount
|
||||
assert!(
|
||||
hex_swap
|
||||
.contains("0c000000000000000000000000000000000000000000000000000000000bebc200"),
|
||||
"partialFillOffset byte (0c) should be followed by original filledTakerAmount"
|
||||
);
|
||||
|
||||
write_calldata_to_file("test_encode_bebop_calldata_forwarding", hex_swap.as_str());
|
||||
write_calldata_to_file("test_encode_bebop_single", hex_swap.as_str());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_encode_bebop_with_aggregate_offset() {
|
||||
use alloy::hex;
|
||||
fn test_encode_bebop_aggregate() {
|
||||
use alloy::{hex, primitives::Address, sol_types::SolValue};
|
||||
|
||||
// Create mock Bebop calldata for swapAggregate
|
||||
let bebop_calldata = hex::decode(
|
||||
"a2f74893".to_owned() // swapAggregate selector
|
||||
+ "0000000000000000000000000000000000000000000000000000000000000001" // mock order data
|
||||
+ "0000000000000000000000000000000000000000000000000000000000000002" // mock signature data
|
||||
+ "00000000000000000000000000000000000000000000000000000000003d0900" // filledTakerAmount
|
||||
).unwrap();
|
||||
// Transaction: https://etherscan.io/tx/0xec88410136c287280da87d0a37c1cb745f320406ca3ae55c678dec11996c1b1c
|
||||
let expiry = 1746367285u64;
|
||||
let taker_address = Address::from_slice(
|
||||
&hex::decode("7078B12Ca5B294d95e9aC16D90B7D38238d8F4E6").unwrap(),
|
||||
);
|
||||
let receiver = taker_address;
|
||||
|
||||
// Set up makers
|
||||
let maker_addresses = vec![
|
||||
Address::from_slice(
|
||||
&hex::decode("67336Cec42645F55059EfF241Cb02eA5cC52fF86").unwrap(),
|
||||
),
|
||||
Address::from_slice(
|
||||
&hex::decode("BF19CbF0256f19f39A016a86Ff3551ecC6f2aAFE").unwrap(),
|
||||
),
|
||||
];
|
||||
let maker_nonces = vec![U256::from(1746367197308u64), U256::from(15460096u64)];
|
||||
|
||||
// 2D arrays for tokens
|
||||
let weth_address = Address::from_slice(
|
||||
&hex::decode("C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2").unwrap(),
|
||||
);
|
||||
let usdc_address = Address::from_slice(
|
||||
&hex::decode("A0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48").unwrap(),
|
||||
);
|
||||
let taker_tokens = vec![vec![weth_address], vec![weth_address]];
|
||||
let maker_tokens = vec![vec![usdc_address], vec![usdc_address]];
|
||||
|
||||
// 2D arrays for amounts
|
||||
let taker_amounts =
|
||||
vec![vec![U256::from(5812106401997138u64)], vec![U256::from(4037893598002862u64)]];
|
||||
let maker_amounts = vec![vec![U256::from(10607211u64)], vec![U256::from(7362350u64)]];
|
||||
|
||||
// Commands and flags from the real transaction
|
||||
let commands = hex::decode("00040004").unwrap();
|
||||
let flags = U256::from_str_radix(
|
||||
"d3fa5d891de82c082d5c51f03b47e826f86c96b88802b96a09bbae087e880000",
|
||||
16,
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
// Encode Aggregate order using ABI encoding
|
||||
let quote_data = (
|
||||
U256::from(expiry),
|
||||
taker_address,
|
||||
maker_addresses,
|
||||
maker_nonces,
|
||||
taker_tokens,
|
||||
maker_tokens,
|
||||
taker_amounts,
|
||||
maker_amounts,
|
||||
receiver,
|
||||
commands,
|
||||
flags,
|
||||
)
|
||||
.abi_encode();
|
||||
|
||||
// Real signatures from mainnet
|
||||
let sig1 = hex::decode("d5abb425f9bac1f44d48705f41a8ab9cae207517be8553d2c03b06a88995f2f351ab8ce7627a87048178d539dd64fd2380245531a0c8e43fdc614652b1f32fc71c").unwrap();
|
||||
let sig2 = hex::decode("f38c698e48a3eac48f184bc324fef0b135ee13705ab38cc0bbf5a792f21002f051e445b9e7d57cf24c35e17629ea35b3263591c4abf8ca87ffa44b41301b89c41b").unwrap();
|
||||
|
||||
// Build the complete swapAggregate calldata
|
||||
let mut bebop_calldata = Vec::new();
|
||||
|
||||
// swapAggregate selector
|
||||
bebop_calldata.extend_from_slice(&[0xa2, 0xf7, 0x48, 0x93]);
|
||||
|
||||
// Calculate filled taker amount (sum of both taker amounts)
|
||||
let filled_taker_amount = U256::from(9850000000000000u64); // Total: 0.00985 WETH
|
||||
|
||||
// Encode parameters: (Aggregate order, MakerSignature[] signatures, uint256
|
||||
// filledTakerAmount) Calculate offsets (relative to start of params, not
|
||||
// selector)
|
||||
let order_offset = U256::from(96); // After 3 words
|
||||
let signatures_offset = U256::from(96 + quote_data.len());
|
||||
|
||||
// Write the three parameter slots
|
||||
bebop_calldata.extend_from_slice(&order_offset.to_be_bytes::<32>());
|
||||
bebop_calldata.extend_from_slice(&signatures_offset.to_be_bytes::<32>());
|
||||
bebop_calldata.extend_from_slice(&filled_taker_amount.to_be_bytes::<32>());
|
||||
|
||||
// Append order data
|
||||
bebop_calldata.extend_from_slice("e_data);
|
||||
|
||||
// Encode MakerSignature[] array
|
||||
// Array length
|
||||
bebop_calldata.extend_from_slice(&U256::from(2).to_be_bytes::<32>());
|
||||
|
||||
// Calculate offsets for each signature struct (relative to start of array data)
|
||||
let sig1_data_size = 32 + 32 + 32 + sig1.len() + ((32 - (sig1.len() % 32)) % 32);
|
||||
let sig1_offset = 64; // After 2 offset words
|
||||
let sig2_offset = sig1_offset + sig1_data_size;
|
||||
|
||||
// Write offsets for each signature
|
||||
bebop_calldata.extend_from_slice(&U256::from(sig1_offset).to_be_bytes::<32>());
|
||||
bebop_calldata.extend_from_slice(&U256::from(sig2_offset).to_be_bytes::<32>());
|
||||
|
||||
// Encode first MakerSignature struct
|
||||
bebop_calldata.extend_from_slice(&U256::from(64).to_be_bytes::<32>()); // offset to bytes
|
||||
bebop_calldata.extend_from_slice(&U256::ZERO.to_be_bytes::<32>()); // flags = 0 (ETH_SIGN)
|
||||
bebop_calldata.extend_from_slice(&U256::from(sig1.len()).to_be_bytes::<32>());
|
||||
bebop_calldata.extend_from_slice(&sig1);
|
||||
let padding1 = (32 - (sig1.len() % 32)) % 32;
|
||||
bebop_calldata.extend(vec![0u8; padding1]);
|
||||
|
||||
// Encode second MakerSignature struct
|
||||
bebop_calldata.extend_from_slice(&U256::from(64).to_be_bytes::<32>()); // offset to bytes
|
||||
bebop_calldata.extend_from_slice(&U256::ZERO.to_be_bytes::<32>()); // flags = 0 (ETH_SIGN)
|
||||
bebop_calldata.extend_from_slice(&U256::from(sig2.len()).to_be_bytes::<32>());
|
||||
bebop_calldata.extend_from_slice(&sig2);
|
||||
let padding2 = (32 - (sig2.len() % 32)) % 32;
|
||||
bebop_calldata.extend(vec![0u8; padding2]);
|
||||
|
||||
// Prepend the partialFillOffset (2 for swapAggregate)
|
||||
let mut user_data = vec![2u8]; // partialFillOffset = 2 for aggregate
|
||||
let mut user_data = vec![2u8];
|
||||
user_data.extend_from_slice(&bebop_calldata);
|
||||
|
||||
// Extract bebop_calldata for verification (skip the first byte which is
|
||||
// partialFillOffset)
|
||||
let bebop_calldata = user_data[1..].to_vec();
|
||||
|
||||
let bebop_component = ProtocolComponent {
|
||||
id: String::from("bebop-rfq"),
|
||||
protocol_system: String::from("rfq:bebop"),
|
||||
@@ -2060,7 +2320,7 @@ mod tests {
|
||||
};
|
||||
|
||||
let encoding_context = EncodingContext {
|
||||
receiver: Bytes::from("0xc5564C13A157E6240659fb81882A28091add8670"),
|
||||
receiver: Bytes::from("0x7078B12Ca5B294d95e9aC16D90B7D38238d8F4E6"), /* Use actual receiver from order */
|
||||
exact_out: false,
|
||||
router_address: Some(Bytes::zero(20)),
|
||||
group_token_in: token_in.clone(),
|
||||
@@ -2083,10 +2343,29 @@ mod tests {
|
||||
.unwrap();
|
||||
let hex_swap = encode(&encoded_swap);
|
||||
|
||||
// Verify the partialFillOffset byte (02 = 2 in hex) appears after the bebop calldata
|
||||
assert!(hex_swap.contains("3d090002")); // filledTakerAmount followed by offset byte
|
||||
// Verify the encoding contains the expected tokens
|
||||
assert!(hex_swap.contains("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2")); // WETH
|
||||
assert!(hex_swap.contains("a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48")); // USDC
|
||||
|
||||
write_calldata_to_file("test_encode_bebop_aggregate_offset", hex_swap.as_str());
|
||||
// Verify it includes the bebop calldata
|
||||
let calldata_hex = hex::encode(&bebop_calldata);
|
||||
assert!(hex_swap.contains(&calldata_hex));
|
||||
|
||||
// Verify the original amount
|
||||
let filled_amount_hex = format!("{:064x}", filled_taker_amount);
|
||||
assert!(
|
||||
hex_swap.contains(&filled_amount_hex),
|
||||
"Should contain filled_taker_amount in hex"
|
||||
);
|
||||
|
||||
// Verify the partialFillOffset byte (02 = 2) appears in the right place
|
||||
let expected_pattern = format!("02{}", filled_amount_hex);
|
||||
assert!(
|
||||
hex_swap.contains(&expected_pattern),
|
||||
"partialFillOffset byte (02) should be followed by original filledTakerAmount"
|
||||
);
|
||||
|
||||
write_calldata_to_file("test_encode_bebop_aggregate", hex_swap.as_str());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user