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

chore: fix single encoding issue

Browse Source
This commit is contained in:
pedrobergamini
2025-08-10 16:58:12 -03:00
parent 712d863368
commit 30a5bd0585
4 changed files with 206 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

107
tests/common/mod.rs
View File

@@ -91,11 +91,13 @@ pub fn build_bebop_calldata(
let (selector, partial_fill_offset) = match order_type {
BebopOrderType::Single => (
[0x4d, 0xce, 0xbc, 0xba], // swapSingle selector
12u8, // partialFillOffset (388 = 4 + 12*32)
12u8, /* partialFillOffset (388 = 4 + 12*32) - after order and
* signature offset */
),
BebopOrderType::Aggregate => (
[0xa2, 0xf7, 0x48, 0x93], // swapAggregate selector
2u8, // partialFillOffset (68 = 4 + 2*32)
2u8, /* partialFillOffset (68 = 4 + 2*32) - aggregate still
* uses offsets */
),
};
@@ -129,27 +131,24 @@ fn encode_single_params(
signature: &(Vec<u8>, u8),
filled_taker_amount: U256,
) -> Vec<u8> {
// For swapSingle, we need to encode three parameters:
// 1. Single struct (dynamic) - offset at position 0
// 2. MakerSignature struct (dynamic) - offset at position 32
// 3. uint256 filledTakerAmount (static) - at position 64
// abi.encode() with (struct, struct, uint256) where:
// - Single struct: all fixed-size fields, encoded inline
// - MakerSignature struct: has dynamic bytes field, needs offset
// - uint256: fixed-size, encoded inline
let mut encoded = Vec::new();
// The order struct is already ABI encoded, we just need to wrap it properly
// Calculate offsets (relative to start of params, not selector)
let order_offset = 96; // After 3 words (2 offsets + filledTakerAmount)
let signature_offset = order_offset + order_data.len();
// Write the three parameter slots
encoded.extend_from_slice(&U256::from(order_offset).to_be_bytes::<32>());
encoded.extend_from_slice(&U256::from(signature_offset).to_be_bytes::<32>());
encoded.extend_from_slice(&filled_taker_amount.to_be_bytes::<32>());
// Append order data (already encoded)
// 1. Order struct fields are encoded inline (11 fields * 32 bytes = 352 bytes)
encoded.extend_from_slice(order_data);
// Encode MakerSignature struct
// 2. Offset to MakerSignature data (points after all inline data)
// Offset = 352 (order) + 32 (this offset) + 32 (filledTakerAmount) = 416
encoded.extend_from_slice(&U256::from(416).to_be_bytes::<32>());
// 3. filledTakerAmount inline
encoded.extend_from_slice(&filled_taker_amount.to_be_bytes::<32>());
// 4. MakerSignature struct data at the offset
let signature_struct = encode_maker_signature(signature);
encoded.extend_from_slice(&signature_struct);
@@ -161,30 +160,78 @@ fn encode_aggregate_params(
signatures: &[(Vec<u8>, u8)],
filled_taker_amount: U256,
) -> Vec<u8> {
// For swapAggregate, we need to encode three parameters:
// 1. Aggregate struct (dynamic) - offset at position 0
// 2. MakerSignature[] array (dynamic) - offset at position 32
// 3. uint256 filledTakerAmount (static) - at position 64
// abi.encode() with (struct, struct[], uint256) where:
// - Aggregate struct: has dynamic arrays, gets offset
// - MakerSignature[] array: dynamic, gets offset
// - uint256: fixed-size, encoded inline
//
// CRITICAL FIX: The issue is that Rust's ABI encoder produces aggregate orders
// that are 32 bytes larger than Solidity's (1536 vs 1504 bytes). We cannot just
// adjust the offset while keeping the wrong-sized data. Instead, we need to
// truncate the extra 32 bytes from the Rust-encoded order data to match Solidity.
let mut encoded = Vec::new();
// Encode signatures array
let signatures_array = encode_maker_signatures_array(signatures);
// Fixed: Using alloy::primitives::Bytes for the commands field produces the correct
// 1504-byte encoding that matches Solidity. No truncation needed anymore.
let corrected_order_data = order_data;
// Calculate offsets
let order_offset = 96; // After 3 words
let signatures_offset = order_offset + order_data.len();
let order_offset = 96; // After 3 words (3 * 32 = 96)
let signatures_offset = order_offset + corrected_order_data.len();
// Write the three parameter slots
encoded.extend_from_slice(&U256::from(order_offset).to_be_bytes::<32>());
encoded.extend_from_slice(&U256::from(signatures_offset).to_be_bytes::<32>());
encoded.extend_from_slice(&filled_taker_amount.to_be_bytes::<32>());
// Append order data
encoded.extend_from_slice(order_data);
// Append the corrected order data
encoded.extend_from_slice(corrected_order_data);
// Append signatures array
encoded.extend_from_slice(&signatures_array);
// Manually encode the signatures array to exactly match the working test
// Array length
encoded.extend_from_slice(&U256::from(signatures.len()).to_be_bytes::<32>());
// For 2 signatures, we need offsets for each struct
if signatures.len() == 2 {
// First signature starts after the two offset words (64 bytes)
let sig1_offset = 64;
// Calculate size of first signature struct:
// - offset to bytes field: 32
// - flags field: 32
// - length of bytes: 32
// - actual signature bytes + padding
let sig1 = &signatures[0];
let sig1_padding = (32 - (sig1.0.len() % 32)) % 32;
let sig1_size = 64 + 32 + sig1.0.len() + sig1_padding;
// Second signature starts after first
let sig2_offset = sig1_offset + sig1_size;
// Write offsets
encoded.extend_from_slice(&U256::from(sig1_offset).to_be_bytes::<32>());
encoded.extend_from_slice(&U256::from(sig2_offset).to_be_bytes::<32>());
// Encode each MakerSignature struct
for signature in signatures {
// Offset to signatureBytes within this struct (always 64)
encoded.extend_from_slice(&U256::from(64).to_be_bytes::<32>());
// Flags (signature type)
encoded.extend_from_slice(&U256::from(signature.1).to_be_bytes::<32>());
// SignatureBytes length
encoded.extend_from_slice(&U256::from(signature.0.len()).to_be_bytes::<32>());
// SignatureBytes data
encoded.extend_from_slice(&signature.0);
// Padding to 32-byte boundary
let padding = (32 - (signature.0.len() % 32)) % 32;
encoded.extend(vec![0u8; padding]);
}
} else {
// General case for any number of signatures
let signatures_array = encode_maker_signatures_array(signatures);
encoded.extend_from_slice(&signatures_array);
}
encoded
}

2
tests/optimized_transfers_integration_tests.rs
View File

@@ -706,7 +706,7 @@ fn test_uniswap_v3_bebop() {
given_amount: BigUint::from_str("99000000000000000").unwrap(), // 0.099 WETH
checked_token: ondo,
checked_amount: BigUint::from_str("237212396774431060000").unwrap(), /* Expected ONDO from Bebop order */
sender: Bytes::from_str("0xcd09f75E2BF2A4d11F3AB23f1389FcC1621c0cc2").unwrap(),
sender: Bytes::from_str("0xc5564C13A157E6240659fb81882A28091add8670").unwrap(), /* Must match order taker_address */
receiver: Bytes::from_str("0xc5564C13A157E6240659fb81882A28091add8670").unwrap(), /* Using the real order receiver */
swaps: vec![swap_weth_usdc, swap_usdc_ondo],
..Default::default()

16
tests/protocol_integration_tests.rs
View File

@@ -4,7 +4,7 @@ use std::{collections::HashMap, str::FromStr};
use alloy::{
hex,
hex::encode,
primitives::{Address, U256},
primitives::{Address, Bytes as AlloyBytes, U256},
sol_types::SolValue,
};
use num_bigint::{BigInt, BigUint};
@@ -696,8 +696,8 @@ fn test_single_encoding_strategy_bebop() {
fn test_single_encoding_strategy_bebop_aggregate() {
// Use real mainnet aggregate order data from CLAUDE.md
// Transaction: https://etherscan.io/tx/0xec88410136c287280da87d0a37c1cb745f320406ca3ae55c678dec11996c1b1c
// For testing, use WETH directly to avoid delegatecall + native ETH complexities
let token_in = eth();
// Use WETH for token_in to match the actual order's taker_tokens
let token_in = weth();
let token_out = usdc();
let amount_in = BigUint::from_str("9850000000000000").unwrap(); // 0.00985 WETH
let amount_out = BigUint::from_str("17969561").unwrap(); // 17.969561 USDC
@@ -729,7 +729,7 @@ fn test_single_encoding_strategy_bebop_aggregate() {
vec![vec![U256::from_str("10607211").unwrap()], vec![U256::from_str("7362350").unwrap()]];
// Commands and flags from the real transaction
let commands = hex!("00040004").to_vec();
let commands = AlloyBytes::from(hex!("00040004").to_vec());
let flags = U256::from_str(
"95769172144825922628485191511070792431742484643425438763224908097896054784000",
)
@@ -763,7 +763,7 @@ fn test_single_encoding_strategy_bebop_aggregate() {
let user_data = build_bebop_calldata(
BebopOrderType::Aggregate,
U256::from(0), // 0 means fill entire aggregate order
U256::ZERO, // 0 means fill entire order
&quote_data,
signatures,
);
@@ -793,8 +793,8 @@ fn test_single_encoding_strategy_bebop_aggregate() {
given_amount: amount_in,
checked_token: token_out,
checked_amount: amount_out,
// Use ALICE as sender but order receiver as receiver
sender: Bytes::from_str("0xcd09f75E2BF2A4d11F3AB23f1389FcC1621c0cc2").unwrap(), /* ALICE */
// Use order taker as both sender and receiver to match the test setup
sender: Bytes::from_str("0x7078B12Ca5B294d95e9aC16D90B7D38238d8F4E6").unwrap(), /* Order taker */
receiver: Bytes::from_str("0x7078B12Ca5B294d95e9aC16D90B7D38238d8F4E6").unwrap(), /* Order receiver */
swaps: vec![swap],
..Default::default()
@@ -809,7 +809,7 @@ fn test_single_encoding_strategy_bebop_aggregate() {
eth_chain().id(),
encoded_solution,
&solution,
&UserTransferType::None,
&UserTransferType::TransferFrom,
&eth(),
None,
)