Struct TwapOrder 

pub struct TwapOrder {
    pub data: TwapData,
    pub salt: B256,
}

A TWAP order ready to be submitted to ComposableCow.

Fields

data: TwapData

The underlying TWAP configuration.

salt: B256

32-byte salt uniquely identifying this order instance.

Implementations

impl TwapOrder

pub fn new(data: TwapData) -> Self

Create a new TWAP order.

The salt is derived deterministically from the order parameters. Use TwapOrder::with_salt to supply an explicit salt.

Example

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

let data = TwapData::sell(Address::ZERO, Address::ZERO, U256::from(1000u64), 4, 3600);
let order = TwapOrder::new(data);
assert_eq!(order.data.num_parts, 4);
assert_eq!(order.data.part_duration, 3600);

pub const fn with_salt(data: TwapData, salt: B256) -> Self

Create a TWAP order with an explicit salt.

Arguments

• data - The TWAP order configuration.
• salt - A caller-chosen 32-byte salt to uniquely identify this order.

Returns

A TwapOrder using the provided salt verbatim.

pub fn to_params(&self) -> Result<ConditionalOrderParams, CowError>

Returns the on-chain ConditionalOrderParams for this order.

Errors

Returns CowError::AppData if ABI encoding fails.

pub fn id(&self) -> Result<B256, CowError>

Unique order ID: keccak256(abi.encode(ConditionalOrderParams)).

Errors

Returns CowError::AppData if encoding fails.

pub fn is_valid(&self) -> bool

Validate the order parameters.

Mirrors the TypeScript SDK Twap.isValid() logic:

• Tokens must differ and must not be the zero address
• sell_amount and buy_amount must be non-zero
• num_parts must be ≥ 2
• part_duration must be > 0 and ≤ MAX_FREQUENCY
• sell_amount must be divisible by num_parts
• If DurationOfPart::LimitDuration: duration must be ≤ part_duration

pub fn per_part_amounts(&self) -> Result<(U256, U256), CowError>

Return the per-part sell and buy amounts (part_sell, min_part_buy).

These are the amounts used in each individual order slice: sell_amount / num_parts and buy_amount / num_parts.

Errors

Returns CowError::AppData if num_parts is zero.

Example

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

let data = TwapData::sell(Address::ZERO, Address::ZERO, U256::from(1000u64), 4, 3600)
    .with_buy_amount(U256::from(800u64));
let order = TwapOrder::new(data);
let (sell, buy) = order.per_part_amounts().unwrap();
assert_eq!(sell, U256::from(250u64));
assert_eq!(buy, U256::from(200u64));

pub fn to_struct(&self) -> Result<TwapStruct, CowError>

Convert this order’s user-facing data into the on-chain TwapStruct representation.

The struct uses per-part amounts and the raw span/t0 fields.

Errors

Returns CowError::AppData if num_parts is zero.

pub fn poll_validate(&self, block_timestamp: u64) -> PollResult

Check tradability of this TWAP order at the given block timestamp.

Returns PollResult::Success if the order is within its execution window, PollResult::TryAtEpoch if the order has not started yet, or PollResult::DontTryAgain if the order has fully expired.

For TwapStartTime::AtMiningTime orders, always returns PollResult::Success because the start time is not known until mined.

impl TwapOrder

pub const fn salt_ref(&self) -> &B256

Returns a reference to the 32-byte salt.

Returns

A shared reference to the B256 salt that uniquely identifies this order instance within a ComposableCow safe.

pub const fn data_ref(&self) -> &TwapData

Returns a reference to the underlying TwapData.

Returns

A shared reference to the TwapData configuration backing this order.

pub const fn total_sell_amount(&self) -> U256

Returns the total sell amount across all parts.

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

let data = TwapData::sell(Address::ZERO, Address::ZERO, U256::from(1_000u64), 4, 3_600);
let order = TwapOrder::new(data);
assert_eq!(order.total_sell_amount(), U256::from(1_000u64));

pub const fn total_buy_amount(&self) -> U256

Returns the total minimum buy amount across all parts.

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

let data = TwapData::sell(Address::ZERO, Address::ZERO, U256::ZERO, 4, 3_600)
    .with_buy_amount(U256::from(800u64));
let order = TwapOrder::new(data);
assert_eq!(order.total_buy_amount(), U256::from(800u64));

pub const fn is_sell(&self) -> bool

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

Returns

true when the order kind is OrderKind::Sell, false otherwise.

pub const fn is_buy(&self) -> bool

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

Returns

true when the order kind is OrderKind::Buy, false otherwise.

pub const fn is_expired_at(&self, block_timestamp: u64) -> bool

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

Delegates to TwapData::is_expired. Returns false when the start time is TwapStartTime::AtMiningTime (end time is unknown until mined).

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

let data = 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
let order = TwapOrder::new(data);
assert!(!order.is_expired_at(1_014_399));
assert!(order.is_expired_at(1_014_400));

pub const fn start_timestamp(&self) -> Option<u32>

Return the fixed start timestamp, or None when the order starts at mining time.

Mirrors TwapData::start_time::timestamp().

Trait Implementations

impl Clone for TwapOrder

fn clone(&self) -> TwapOrder

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TwapOrder

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

Formats the value using the given formatter.

impl Display for TwapOrder

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

Formats the value using the given formatter.