feat: honor preferred filler order windows

- Add `additionalValidationContract` and `additionalValidationData` fields to `OrderParams` struct to support UniswapX validation callbacks
- Update EIP-712 order info hashing to use actual validation contract and data instead of hardcoded zero address and empty bytes
- Extend `RestingOrder` to include additional validation fields parsed from indexer responses
- Update resting limit orders GraphQL query to request validation fields and filter by filler wallet
- Pass filler wallet address to indexer when querying resting limit orders
- Update order encoding to properly serialize variable-length validation data within OrderInfo structure
- Initialize validation fields to zero/empty in all order creation paths (poster, submit tests, taker tests)

Author: bnolens

.textile-monorepo-source

@@ -1 +1 @@
-5e2592c55a6c3cae76a904c4c544fc7893a455cd
+b2f439ffb798cf657f9f1dee4d033a76750c1414

.textile-stitch-release-version

@@ -1 +1 @@
-0.1.122
+0.1.123

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "stitch-bot"
-version = "0.1.122"
+version = "0.1.123"
 edition = "2021"
 description = "Stitch — Textile filler-network operator bot; market-makes the filler order book with signed UniswapX limit orders."
 license = "AGPL-3.0-or-later"

Cargo.toml

@@ -81,15 +81,14 @@ fn hash_words(words: &[[u8; 32]]) -> B256 {
 }
 
 fn order_info_hash(o: &OrderParams) -> B256 {
-    let empty_validation_data = keccak256([]); // keccak256("")
     hash_words(&[
         b256_word(k(ORDER_INFO_TYPE)),
         addr_word(o.reactor),
         addr_word(o.swapper),
         u256_word(o.nonce),
         u256_word(o.deadline),
-        addr_word(Address::ZERO), // additionalValidationContract
-        b256_word(empty_validation_data),
+        addr_word(o.additional_validation_contract),
+        b256_word(keccak256(&o.additional_validation_data)),
     ])
 }
 
@@ -175,6 +174,8 @@ mod tests {
             output_token: address!("4444444444444444444444444444444444444444"), // cNGN
             output_amount: U256::from(1_550_000_000u64),
             recipient: address!("2222222222222222222222222222222222222222"),
+            additional_validation_contract: Address::ZERO,
+            additional_validation_data: Default::default(),
         }
     }
 

src/eip712.rs

@@ -16,9 +16,10 @@ const COMMITTED_INPUT_QUERY: &str =
     "query CommittedInput($chainId: Int!, $maker: String!, $inputToken: String!) { \
 fillerCommittedInput(chainId: $chainId, maker: $maker, inputToken: $inputToken) }";
 const RESTING_LIMIT_ORDERS_QUERY: &str =
-    "query RestingLimitOrders($chainId: Int!, $inputToken: String!, $outputToken: String!) { \
-restingLimitOrders(chainId: $chainId, inputToken: $inputToken, outputToken: $outputToken) { \
-id reactor maker inputToken inputAmount outputToken outputAmount rateRay nonce deadlineSec signature } }";
+    "query RestingLimitOrders($chainId: Int!, $inputToken: String!, $outputToken: String!, $fillerWallet: String!) { \
+  restingLimitOrders(chainId: $chainId, inputToken: $inputToken, outputToken: $outputToken, fillerWallet: $fillerWallet) { \
+id reactor maker inputToken inputAmount outputToken outputAmount rateRay nonce deadlineSec \
+additionalValidationContract additionalValidationData signature } }";
 
 /// Build the GraphQL request body for one order (pure — easy to assert on).
 pub fn build_submit_request(order: &SubmitOrder) -> Value {
@@ -53,13 +54,15 @@ pub fn build_resting_limit_orders_request(
     chain_id: u64,
     input_token: &str,
     output_token: &str,
+    filler_wallet: &str,
 ) -> Value {
     json!({
         "query": RESTING_LIMIT_ORDERS_QUERY,
         "variables": {
             "chainId": chain_id,
             "inputToken": input_token,
             "outputToken": output_token,
+            "fillerWallet": filler_wallet,
         }
     })
 }
@@ -163,8 +166,10 @@ impl Indexer {
         chain_id: u64,
         input_token: &str,
         output_token: &str,
+        filler_wallet: &str,
     ) -> anyhow::Result<Value> {
-        let body = build_resting_limit_orders_request(chain_id, input_token, output_token);
+        let body =
+            build_resting_limit_orders_request(chain_id, input_token, output_token, filler_wallet);
         let resp = self.post_graphql(&body, "resting limit orders").await?;
         Ok(resp
             .pointer("/data/restingLimitOrders")

src/indexer.rs

@@ -83,6 +83,8 @@ impl Poster<'_> {
                     output_token,
                     output_amount: draft.output_amount,
                     recipient: self.maker,
+                    additional_validation_contract: Address::ZERO,
+                    additional_validation_data: Default::default(),
                 };
                 Some((order, draft.client_order_id.clone()))
             })
@@ -274,6 +276,8 @@ mod tests {
             output_token: Address::ZERO,
             output_amount: U256::from(1u64),
             recipient: Address::ZERO,
+            additional_validation_contract: Address::ZERO,
+            additional_validation_data: Default::default(),
         }
     }
 

src/poster.rs

@@ -79,6 +79,8 @@ mod tests {
             output_token: address!("4444444444444444444444444444444444444444"),
             output_amount: U256::from(1_550_000_000u64),
             recipient: maker,
+            additional_validation_contract: Address::ZERO,
+            additional_validation_data: Default::default(),
         };
 
         let s = sign_submission(&order, PERMIT2, 8453, &signer)

src/submit.rs

@@ -66,6 +66,8 @@ pub struct RestingOrder {
     pub output_amount: U256,
     pub nonce: U256,
     pub deadline_sec: u64,
+    pub additional_validation_contract: Address,
+    pub additional_validation_data: Bytes,
     /// 65-byte EIP-712 signature over the Permit2 witness digest.
     pub signature: Vec<u8>,
 }
@@ -85,6 +87,8 @@ impl RestingOrder {
             output_token: self.output_token,
             output_amount: self.output_amount,
             recipient: self.maker,
+            additional_validation_contract: self.additional_validation_contract,
+            additional_validation_data: self.additional_validation_data.clone(),
         }
     }
 }
@@ -109,6 +113,11 @@ fn parse_signature_field(v: &Value) -> Option<Vec<u8>> {
     (bytes.len() == 65).then_some(bytes)
 }
 
+fn parse_bytes_field(v: &Value) -> Option<Bytes> {
+    let value = v.as_str()?;
+    alloy_primitives::hex::decode(value).ok().map(Bytes::from)
+}
+
 /// Parse the `restingLimitOrders` response rows; malformed rows are dropped
 /// (they can only have come from a broken or hostile indexer).
 pub fn parse_resting_orders(rows: &Value) -> Vec<RestingOrder> {
@@ -126,6 +135,14 @@ pub fn parse_resting_orders(rows: &Value) -> Vec<RestingOrder> {
                         output_amount: parse_u256_field(row.get("outputAmount")?)?,
                         nonce: parse_u256_field(row.get("nonce")?)?,
                         deadline_sec: parse_u256_field(row.get("deadlineSec")?)?.try_into().ok()?,
+                        additional_validation_contract: row
+                            .get("additionalValidationContract")
+                            .and_then(parse_address_field)
+                            .unwrap_or(Address::ZERO),
+                        additional_validation_data: row
+                            .get("additionalValidationData")
+                            .and_then(parse_bytes_field)
+                            .unwrap_or_default(),
                         signature: parse_signature_field(row.get("signature")?)?,
                     })
                 })
@@ -294,7 +311,9 @@ fn word_address(a: Address) -> [u8; 32] {
 /// encoding locally from verified fields is what keeps a hostile indexer's
 /// `encodedOrder` out of the transaction entirely.
 pub fn encode_order_bytes(o: &OrderParams) -> Vec<u8> {
-    let mut out = Vec::with_capacity(17 * 32);
+    let validation_data = padded_bytes(&o.additional_validation_data);
+    let info_size = 6 * 32 + validation_data.len();
+    let mut out = Vec::with_capacity(10 * 32 + info_size);
     out.extend_from_slice(&word_usize(0x20)); // offset to the tuple
 
     // Tuple head: [info offset, input.token, input.amount, input.maxAmount,
@@ -304,16 +323,16 @@ pub fn encode_order_bytes(o: &OrderParams) -> Vec<u8> {
     out.extend_from_slice(&word_address(o.input_token));
     out.extend_from_slice(&word_u256(o.input_amount));
     out.extend_from_slice(&word_u256(o.input_amount)); // maxAmount == amount
-    out.extend_from_slice(&word_usize(5 * 32 + 7 * 32)); // outputs after info
+    out.extend_from_slice(&word_usize(5 * 32 + info_size)); // outputs after info
 
-    // OrderInfo: 5 static words + offset to empty `additionalValidationData`.
+    // OrderInfo: 5 static words + offset to `additionalValidationData`.
     out.extend_from_slice(&word_address(o.reactor));
     out.extend_from_slice(&word_address(o.swapper));
     out.extend_from_slice(&word_u256(o.nonce));
     out.extend_from_slice(&word_u256(o.deadline));
-    out.extend_from_slice(&word_address(Address::ZERO));
+    out.extend_from_slice(&word_address(o.additional_validation_contract));
     out.extend_from_slice(&word_usize(6 * 32)); // bytes offset within info
-    out.extend_from_slice(&word_usize(0)); // len(additionalValidationData)
+    out.extend_from_slice(&validation_data);
 
     // OutputToken[1]
     out.extend_from_slice(&word_usize(1));
@@ -476,6 +495,7 @@ async fn take_direction_once(
             chain_id,
             &input_token.to_string(),
             &output_token.to_string(),
+            &wallet.address().to_string(),
         )
         .await?;
     let orders = parse_resting_orders(&rows);
@@ -648,6 +668,8 @@ mod tests {
             output_amount: U256::from(1_000_000u64),
             nonce: U256::from(42u64),
             deadline_sec,
+            additional_validation_contract: Address::ZERO,
+            additional_validation_data: Default::default(),
             signature: vec![],
         };
         let digest = permit2_digest(&order.params(), PERMIT2, CHAIN);
@@ -834,6 +856,8 @@ mod tests {
             output_token: CNGN,
             output_amount: U256::from(1_550_000_000u64),
             recipient: address!("2222222222222222222222222222222222222222"),
+            additional_validation_contract: Address::ZERO,
+            additional_validation_data: Default::default(),
         }
     }
 

src/taker.rs

@@ -2,7 +2,7 @@
 // Copyright (c) 2026 Textile, Inc.
 //! Shared types for the operator bot.
 
-pub use alloy_primitives::{Address, B256, U256};
+pub use alloy_primitives::{Address, Bytes, B256, U256};
 
 /// One operator limit order: pay `input_amount` debt (USDT) to buy
 /// `output_amount` collateral (cNGN). For a limit order (no Dutch decay) the
@@ -28,4 +28,8 @@ pub struct OrderParams {
     pub output_amount: U256,
     /// Where the bought collateral lands (the operator's wallet).
     pub recipient: Address,
+    /// Optional UniswapX validation callback; zero for operator quote orders.
+    pub additional_validation_contract: Address,
+    /// ABI-encoded callback parameters; empty for operator quote orders.
+    pub additional_validation_data: Bytes,
 }