Struct UnsignedOrder 

pub struct UnsignedOrder {
    pub sell_token: Address,
    pub buy_token: Address,
    pub receiver: Address,
    pub sell_amount: Uint<256, 4>,
    pub buy_amount: Uint<256, 4>,
    pub valid_to: u32,
    pub app_data: FixedBytes<32>,
    pub fee_amount: Uint<256, 4>,
    pub kind: OrderKind,
    pub partially_fillable: bool,
    pub sell_token_balance: TokenBalance,
    pub buy_token_balance: TokenBalance,
}

An unsigned CoW Protocol order ready to be hashed and signed.

Fields

sell_token: Address

Token to sell.

buy_token: Address

Token to buy.

receiver: Address

Address that receives the bought tokens.

sell_amount: Uint<256, 4>

Amount of sell_token to sell (after fee, in atoms).

buy_amount: Uint<256, 4>

Minimum amount of buy_token to receive (in atoms).

valid_to: u32

Order expiry as Unix timestamp.

app_data: FixedBytes<32>

App-data hash (bytes32).

fee_amount: Uint<256, 4>

Protocol fee included in sell_amount (in atoms).

kind: OrderKind

Sell or buy direction.

partially_fillable: bool

Whether the order may be partially filled.

sell_token_balance: TokenBalance

Source of sell funds.

buy_token_balance: TokenBalance

Destination of buy funds.

Implementations

impl UnsignedOrder

pub const fn sell( sell_token: Address, buy_token: Address, sell_amount: Uint<256, 4>, buy_amount: Uint<256, 4>, ) -> UnsignedOrder

Construct a sell order with defaults: ERC-20 balances, fee_amount = 0, app_data = B256::ZERO, valid_to = 0, receiver = Address::ZERO.

Use the builder methods to override any field before signing.

Arguments

• sell_token - Address of the token to sell.
• buy_token - Address of the token to buy.
• sell_amount - Amount of sell_token to sell (in atoms).
• buy_amount - Minimum amount of buy_token to receive (in atoms).

Returns

A new UnsignedOrder with OrderKind::Sell and sensible defaults.

pub const fn buy( sell_token: Address, buy_token: Address, sell_amount: Uint<256, 4>, buy_amount: Uint<256, 4>, ) -> UnsignedOrder

Construct a buy order with defaults: ERC-20 balances, fee_amount = 0, app_data = B256::ZERO, valid_to = 0, receiver = Address::ZERO.

Arguments

• sell_token - Address of the token to sell.
• buy_token - Address of the token to buy.
• sell_amount - Maximum amount of sell_token willing to sell (in atoms).
• buy_amount - Amount of buy_token to buy (in atoms).

Returns

A new UnsignedOrder with OrderKind::Buy and sensible defaults.

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

Override the receiver address.

pub const fn with_valid_to(self, valid_to: u32) -> UnsignedOrder

Set the order expiry as a Unix timestamp.

pub const fn with_app_data(self, app_data: FixedBytes<32>) -> UnsignedOrder

Set the app-data hash.

pub const fn with_fee_amount(self, fee_amount: Uint<256, 4>) -> UnsignedOrder

Override the fee amount (defaults to zero).

pub const fn with_partially_fillable(self) -> UnsignedOrder

Allow partial fills.

pub const fn with_sell_token_balance( self, balance: TokenBalance, ) -> UnsignedOrder

Override the sell-token balance source.

pub const fn with_buy_token_balance( self, balance: TokenBalance, ) -> UnsignedOrder

Override the buy-token balance destination.

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

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

An order is expired when timestamp > valid_to.

use alloy_primitives::{Address, U256};
use cow_types::UnsignedOrder;

let order = UnsignedOrder::sell(Address::ZERO, Address::ZERO, U256::ZERO, U256::ZERO)
    .with_valid_to(1_000_000);
assert!(!order.is_expired(999_999));
assert!(!order.is_expired(1_000_000)); // valid_to is inclusive
assert!(order.is_expired(1_000_001));

pub const fn is_sell(&self) -> bool

Returns true if this is a sell-direction order.

pub const fn is_buy(&self) -> bool

Returns true if this is a buy-direction order.

pub fn has_custom_receiver(&self) -> bool

Returns true if a non-zero receiver address is set.

pub fn has_app_data(&self) -> bool

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

pub fn has_fee(&self) -> bool

Returns true if the fee amount is non-zero.

pub const fn is_partially_fillable(&self) -> bool

Returns true if this order allows partial fills.

pub const fn total_amount(&self) -> Uint<256, 4>

Returns the total token amount at stake: sell_amount + buy_amount.

Uses saturating addition to avoid overflow on extreme values.

Trait Implementations

impl Clone for UnsignedOrder

fn clone(&self) -> UnsignedOrder

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for UnsignedOrder

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

Formats the value using the given formatter.

impl Display for UnsignedOrder

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

Formats the value using the given formatter.

impl TryFrom<&GpV2OrderStruct> for UnsignedOrder

fn try_from( s: &GpV2OrderStruct, ) -> Result<UnsignedOrder, <UnsignedOrder as TryFrom<&GpV2OrderStruct>>::Error>

Decode a raw GpV2OrderStruct into a fully typed UnsignedOrder.

Resolves the hashed kind, sell_token_balance, and buy_token_balance fields back into their enum representations via crate::from_struct_to_order.

type Error = CowError

The type returned in the event of a conversion error.