Struct Order 

pub struct Order {

    pub uid: String,
    pub owner: Address,
    pub creation_date: String,
    pub status: OrderStatus,
    pub class: Option<OrderClass>,
    pub sell_token: Address,
    pub buy_token: Address,
    pub receiver: Option<Address>,
    pub sell_amount: String,
    pub buy_amount: String,
    pub valid_to: u32,
    pub app_data: String,
    pub full_app_data: Option<String>,
    pub fee_amount: String,
    pub kind: OrderKind,
    pub partially_fillable: bool,
    pub executed_sell_amount: String,
    pub executed_buy_amount: String,
    pub executed_sell_amount_before_fees: String,
    pub executed_fee_amount: String,
    pub invalidated: bool,
    pub is_liquidity_order: Option<bool>,
    pub signing_scheme: SigningScheme,
    pub signature: String,
    pub interactions: Option<OrderInteractions>,
    pub total_fee: Option<String>,
    pub full_fee_amount: Option<String>,
    pub available_balance: Option<String>,
    pub quote_id: Option<i64>,
    pub executed_fee: Option<String>,
    pub ethflow_data: Option<EthflowData>,
    pub onchain_order_data: Option<OnchainOrderData>,
    pub onchain_user: Option<Address>,
}

A full order record returned by GET /api/v1/orders/{uid}.

Fields

uid: String

Unique order identifier.

owner: Address

Owner / signer address.

creation_date: String

When the order was submitted (ISO 8601).

status: OrderStatus

Current lifecycle status.

class: Option<OrderClass>

Market, limit, or liquidity.

sell_token: Address

Token to sell.

buy_token: Address

Token to buy.

receiver: Option<Address>

Receiver address.

sell_amount: String

Requested sell amount.

buy_amount: String

Minimum buy amount.

valid_to: u32

Order expiry.

app_data: String

App-data hash (bytes32 hex).

full_app_data: Option<String>

Full app-data JSON, if it was previously uploaded to the orderbook.

fee_amount: String

Protocol fee.

kind: OrderKind

Sell or buy.

partially_fillable: bool

Partial fill flag.

executed_sell_amount: String

Amount of sell token executed so far.

executed_buy_amount: String

Amount of buy token executed so far.

executed_sell_amount_before_fees: String

Sell amount executed before fees.

executed_fee_amount: String

Fee amount executed so far.

invalidated: bool

Whether the order has been invalidated on-chain.

is_liquidity_order: Option<bool>

Whether this is a liquidity (solver-internal) order rather than an active user order.

signing_scheme: SigningScheme

Signing scheme.

signature: String

Hex-encoded signature.

interactions: Option<OrderInteractions>

On-chain interaction hooks attached to this order.

total_fee: Option<String>

Total fee paid by the order (network + protocol fees, in sell-token atoms).

Present on enriched order responses (EnrichedOrder in the TypeScript SDK).

full_fee_amount: Option<String>

Unsubsidised fee amount (what the fee would be without CoW subsidies).

available_balance: Option<String>

Available sell-token balance of the order owner at the time of query.

quote_id: Option<i64>

Quote ID used when placing the order (for analytics / fee attribution).

executed_fee: Option<String>

Fee actually executed by the solver (separate from executed_fee_amount for orders with both network and protocol fee components).

ethflow_data: Option<EthflowData>

For EthFlow orders: metadata set by the EthFlow contract.

onchain_order_data: Option<OnchainOrderData>

For on-chain placed orders: the sender address and any placement error.

onchain_user: Option<Address>

For EthFlow orders: the true user address (the EthFlow contract is the technical owner; onchain_user is the human behind it).

Implementations

impl Order

pub const fn is_sell(&self) -> bool

Returns true if this is a sell order.

pub const fn is_buy(&self) -> bool

Returns true if this is a buy order.

pub fn effective_receiver(&self) -> Address

Returns the effective receiver: receiver if set, otherwise owner.

When an order omits the explicit receiver the protocol routes proceeds back to the order owner.

pub fn has_interactions(&self) -> bool

Returns true if this order has at least one on-chain interaction hook.

pub const fn has_surplus(&self) -> bool

Returns true if a surplus value is available (enriched order response).

pub const fn has_executed_fee(&self) -> bool

Returns true if the executed fee is available (enriched order response).

pub const fn has_available_balance(&self) -> bool

Returns true if the available sell-token balance of the owner is populated.

pub const fn is_invalidated(&self) -> bool

Returns true if this order has been invalidated on-chain.

pub const fn has_full_app_data(&self) -> bool

Returns true if the full app-data JSON is available.

pub const fn has_ethflow_data(&self) -> bool

Returns true if this order carries EthFlow metadata.

pub const fn has_onchain_data(&self) -> bool

Returns true if this order carries on-chain placement metadata.

pub const fn has_onchain_user(&self) -> bool

Returns true if the onchain_user address (real user behind an EthFlow order) is set.

pub const fn has_receiver(&self) -> bool

Returns true if a custom receiver address is set.

When false, proceeds are routed to owner (see Self::effective_receiver).

pub const fn has_class(&self) -> bool

Returns true if the order class is available.

pub const fn has_quote_id(&self) -> bool

Returns true if a quote ID is attached to this order.

pub const fn has_full_fee_amount(&self) -> bool

Returns true if the unsubsidised fee amount is available (enriched order response).

pub const fn is_partially_fillable(&self) -> bool

Returns true if this order may be partially filled.

pub fn is_liquidity_order(&self) -> bool

Returns true if this order is explicitly marked as a liquidity (solver-internal) order.

Returns false when the is_liquidity_order field is absent or false.

pub const fn is_eth_flow(&self) -> bool

Returns true if this is an EthFlow (native sell) order.

An order is considered an EthFlow order when it carries on-chain placement metadata (Self::onchain_order_data is Some).

use alloy_primitives::Address;
use cow_orderbook::{OnchainOrderData, Order};

// Minimal Order construction is not possible without a full JSON fixture,
// so we just assert the predicate's behaviour here.
let data = OnchainOrderData::new(Address::ZERO);
assert!(!data.has_placement_error()); // just checking it's accessible

pub fn total_executed_fee(&self) -> Option<Uint<256, 4>>

Compute the total executed fee for this order, if available.

Returns Some(executed_fee_amount + executed_fee) when both fields can be parsed as U256. Returns None when either field is missing or unparsable.

The executed fee is the sum of:

• executed_fee_amount — the network (gas) fee taken from the sell token
• executed_fee — the additional protocol fee (present on enriched responses)

use alloy_primitives::U256;
use cow_orderbook::Order;

// Verify we can access total_executed_fee without panicking.
// Full Order construction requires a JSON fixture; just check the return type.
fn _typecheck(order: &Order) -> Option<U256> {
    order.total_executed_fee()
}

pub const fn transform_eth_flow(self, _chain_id: u64) -> Order

Normalise an EthFlow order so it looks like a regular order.

Applies the following transformations:

• sell_token is replaced with the native-currency sentinel address for chain_id (currently always 0xEeee…EeEe).
• owner is replaced with onchain_user (the real user behind the EthFlow contract), if present.

This mirrors transformEthFlowOrder from the TypeScript SDK. Non-EthFlow orders are returned unchanged.

use cow_orderbook::Order;

// Verify the method is accessible; full construction requires a JSON fixture.
fn _typecheck(order: Order) -> Order {
    order.transform_eth_flow(1)
}

Trait Implementations

impl Clone for Order

fn clone(&self) -> Order

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Order

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Order

fn deserialize<__D>( __deserializer: __D, ) -> Result<Order, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Order

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

Formats the value using the given formatter.

impl Serialize for Order

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

where __S: Serializer,

Serialize this value into the given Serde serializer.