Struct TwapData 

pub struct TwapData {
    pub sell_token: Address,
    pub buy_token: Address,
    pub receiver: Address,
    pub sell_amount: U256,
    pub buy_amount: U256,
    pub start_time: TwapStartTime,
    pub part_duration: u32,
    pub num_parts: u32,
    pub app_data: B256,
    pub partially_fillable: bool,
    pub kind: OrderKind,
    pub duration_of_part: DurationOfPart,
}

Parameters for a Time-Weighted Average Price (TWAP) order.

A TWAP order splits a large trade into num_parts equal parts executed over num_parts × part_duration seconds, reducing market impact.

Fields

sell_token: Address

Token to sell.

buy_token: Address

Token to buy.

receiver: Address

Address to receive bought tokens (use Address::ZERO for the order owner).

sell_amount: U256

Total amount to sell across all parts.

buy_amount: U256

Minimum total amount to buy across all parts.

start_time: TwapStartTime

When to start the TWAP.

part_duration: u32

Duration of each part in seconds.

num_parts: u32

Number of parts to split the order into.

app_data: B256

App-data hash (use B256::ZERO for none).

partially_fillable: bool

Whether each individual part may be partially filled.

kind: OrderKind

Order kind (Sell or Buy).

duration_of_part: DurationOfPart

How long each part remains valid within its window.

Defaults to DurationOfPart::Auto (full window, span = 0).

Implementations

impl TwapData

pub const fn total_duration_secs(&self) -> u64

Total duration of the TWAP order in seconds.

Equals num_parts × part_duration.

Returns

The total duration in seconds as a u64.

pub const fn end_time(&self) -> Option<u64>

Absolute Unix timestamp at which the last part expires, if the start time is known.

Returns

Some(end_timestamp) when start_time is TwapStartTime::At, computed as start + total_duration_secs(). Returns None when start_time is TwapStartTime::AtMiningTime (the exact start is only known at mining time).

pub const fn is_sell(&self) -> bool

Returns true if this is a sell-direction TWAP order.

use alloy_primitives::{Address, U256};
use cow_composable::TwapData;

let twap = TwapData::sell(Address::ZERO, Address::ZERO, U256::ZERO, 4, 3_600);
assert!(twap.is_sell());
assert!(!twap.is_buy());

pub const fn is_buy(&self) -> bool

Returns true if this is a buy-direction TWAP order.

use alloy_primitives::{Address, U256};
use cow_composable::{TwapData, TwapStartTime};
use cow_types::OrderKind;

let mut twap = TwapData::sell(Address::ZERO, Address::ZERO, U256::ZERO, 4, 3_600);
twap.kind = OrderKind::Buy;
assert!(twap.is_buy());
assert!(!twap.is_sell());

pub const fn is_expired(&self, timestamp: u64) -> bool

Returns true if the TWAP has fully expired at the given Unix timestamp.

Returns false when start_time is TwapStartTime::AtMiningTime (the end time is not yet known).

use alloy_primitives::{Address, U256};
use cow_composable::{TwapData, TwapStartTime};

let twap = TwapData::sell(Address::ZERO, Address::ZERO, U256::ZERO, 4, 3_600)
    .with_start_time(TwapStartTime::At(1_000_000));
// ends at 1_000_000 + 4 × 3600 = 1_014_400
assert!(!twap.is_expired(1_014_399));
assert!(twap.is_expired(1_014_400));

pub const fn sell( sell_token: Address, buy_token: Address, sell_amount: U256, num_parts: u32, part_duration: u32, ) -> Self

Create a minimal sell-kind TWAP order.

Defaults: receiver = Address::ZERO, buy_amount = U256::ZERO (no min), start_time = TwapStartTime::AtMiningTime, app_data = B256::ZERO, partially_fillable = false, duration_of_part = DurationOfPart::Auto.

Use the with_* builder methods to set optional fields.

Arguments

• sell_token - Address of the token to sell.
• buy_token - Address of the token to buy.
• sell_amount - Total amount of sell_token to sell across all parts.
• num_parts - Number of parts to split the order into.
• part_duration - Duration of each part in seconds.

Returns

A new TwapData configured as a sell order with sensible defaults.

pub const fn buy( sell_token: Address, buy_token: Address, buy_amount: U256, num_parts: u32, part_duration: u32, ) -> Self

Create a minimal buy-kind TWAP order.

Defaults: receiver = Address::ZERO, sell_amount = U256::MAX (unlimited), start_time = TwapStartTime::AtMiningTime, app_data = B256::ZERO, partially_fillable = false, duration_of_part = DurationOfPart::Auto.

Use the with_* builder methods to set optional fields.

Arguments

• sell_token - Address of the token to sell.
• buy_token - Address of the token to buy.
• buy_amount - Minimum total amount of buy_token to receive across all parts.
• num_parts - Number of parts to split the order into.
• part_duration - Duration of each part in seconds.

Returns

A new TwapData configured as a buy order with sensible defaults.

pub const fn with_receiver(self, receiver: Address) -> Self

Set the receiver address for bought tokens.

Address::ZERO means the order owner (default).

Returns

The modified TwapData with the updated receiver (builder pattern).

pub const fn with_buy_amount(self, buy_amount: U256) -> Self

Set the minimum amount of buy_token to receive across all parts.

Useful when building a sell-kind order to set a price floor.

Returns

The modified TwapData with the updated buy amount (builder pattern).

pub const fn with_sell_amount(self, sell_amount: U256) -> Self

Set the maximum amount of sell_token to sell across all parts.

Useful when building a buy-kind order to cap spending.

Returns

The modified TwapData with the updated sell amount (builder pattern).

pub const fn with_start_time(self, start_time: TwapStartTime) -> Self

Set when the TWAP order starts executing.

Returns

The modified TwapData with the updated start time (builder pattern).

pub const fn with_app_data(self, app_data: B256) -> Self

Attach an app-data hash to the order.

Returns

The modified TwapData with the updated app-data hash (builder pattern).

pub const fn with_partially_fillable(self, partially_fillable: bool) -> Self

Allow each individual part to be partially filled.

Returns

The modified TwapData with the updated partial-fill setting (builder pattern).

pub const fn with_duration_of_part( self, duration_of_part: DurationOfPart, ) -> Self

Restrict each part to a shorter validity window within its overall interval.

Returns

The modified TwapData with the updated duration-of-part setting (builder pattern).

pub fn has_app_data(&self) -> bool

Returns true if a non-zero app-data hash is attached.

The zero hash (B256::ZERO) means no app-data was set.

use alloy_primitives::{Address, B256, U256};
use cow_composable::TwapData;

let twap = TwapData::sell(Address::ZERO, Address::ZERO, U256::ZERO, 4, 3_600);
assert!(!twap.has_app_data());

let with_data = twap.with_app_data(B256::repeat_byte(0x01));
assert!(with_data.has_app_data());

Trait Implementations

impl Clone for TwapData

fn clone(&self) -> TwapData

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TwapData

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TwapData

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for TwapData

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<&TwapStruct> for TwapData

fn from(s: &TwapStruct) -> Self

Convert an ABI-level TwapStruct back into a high-level TwapData.

Delegates to crate::struct_to_data.

impl Serialize for TwapData

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&TwapData> for TwapStruct

fn try_from(d: &TwapData) -> Result<Self, Self::Error>

Convert a high-level TwapData into the ABI-level TwapStruct.

Delegates to crate::data_to_struct.

type Error = CowError

The type returned in the event of a conversion error.