Struct Multiplexer 

pub struct Multiplexer { /* private fields */ }

Manages a set of conditional orders and computes their Merkle root.

The Merkle tree follows the OpenZeppelin MerkleTree standard used by the ComposableCow contract:

• Leaf = keccak256(keccak256(abi.encode(params)))
• Node = keccak256(min(left, right) ++ max(left, right))
• Root is verified on-chain by ComposableCow::setRoot.

Implementations

impl Multiplexer

pub const fn new(proof_location: ProofLocation) -> Self

Create an empty multiplexer with the given proof location.

Arguments

• proof_location — where the Merkle proofs will be stored or published (e.g. ProofLocation::Emitted, ProofLocation::Ipfs).

Returns

A new, empty Multiplexer configured with the specified proof location.

pub fn add(&mut self, params: ConditionalOrderParams)

Add a conditional order to the managed set.

The order is appended to the end; its position index can be used with proof or get_by_index.

Arguments

• params — the ConditionalOrderParams describing the order to add.

pub fn remove(&mut self, id: B256)

Remove the first conditional order whose order_id matches id.

If no order matches, this is a no-op.

Arguments

• id — the keccak256-based order identifier to match against.

pub fn update( &mut self, index: usize, params: ConditionalOrderParams, ) -> Result<(), CowError>

Update the order at index with new params.

Errors

Returns CowError::AppData if index is out of range.

pub fn get_by_index(&self, index: usize) -> Option<&ConditionalOrderParams>

Retrieve the order at index.

Arguments

• index — zero-based position of the order in the managed set.

Returns

Some(&ConditionalOrderParams) if the index is valid, or None if out of range.

pub fn get_by_id(&self, id: B256) -> Option<&ConditionalOrderParams>

Retrieve the first order matching id.

Arguments

• id — the keccak256-based order identifier to search for.

Returns

Some(&ConditionalOrderParams) for the first order whose computed order_id equals id, or None if no order matches.

pub const fn len(&self) -> usize

Number of orders currently managed.

Returns

The count of conditional orders in the managed set.

pub const fn is_empty(&self) -> bool

True if no orders are managed.

Returns

true when the multiplexer contains zero orders, false otherwise.

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

Compute the Merkle root of all managed orders.

The root is computed using the OpenZeppelin MerkleTree algorithm: each leaf is keccak256(keccak256(abi.encode(params))) and internal nodes are keccak256(min(left, right) ++ max(left, right)).

Returns None if there are no orders.

Errors

Returns CowError::AppData if ABI encoding of any order fails.

pub fn proof(&self, index: usize) -> Result<OrderProof, CowError>

Generate a Merkle inclusion proof for the order at position index.

Returns the sibling hashes needed to verify membership against the root computed by root.

Errors

Returns CowError::AppData if index is out of range.

pub fn dump_proofs_and_params(&self) -> Result<Vec<ProofWithParams>, CowError>

Export all orders with their Merkle proofs — useful for watchtower services.

Errors

Returns CowError::AppData if proof generation fails.

pub fn order_ids(&self) -> impl Iterator<Item = B256> + '_

Iterate over the order IDs of all managed conditional orders.

Each ID is the keccak256 hash of the ABI-encoded ConditionalOrderParams as computed by order_id.

Returns

An iterator yielding the B256 identifier for each managed order.

pub fn iter(&self) -> impl Iterator<Item = &ConditionalOrderParams>

Iterate over all managed conditional orders.

Returns

An iterator yielding shared references to each ConditionalOrderParams in insertion order.

pub fn as_slice(&self) -> &[ConditionalOrderParams]

View all managed orders as a slice.

Returns

A borrowed slice of all ConditionalOrderParams in insertion order.

pub fn clear(&mut self)

Remove all managed orders.

pub const fn proof_location(&self) -> ProofLocation

The configured proof location.

Returns

The ProofLocation variant that was set at construction or via with_proof_location.

pub const fn with_proof_location(self, location: ProofLocation) -> Self

Override the proof location and return self (builder style).

Arguments

• location — the new ProofLocation to use.

Returns

The same Multiplexer with its proof location updated, enabling builder-style chaining.

pub fn into_vec(self) -> Vec<ConditionalOrderParams>

Consume the multiplexer and return the managed orders as a Vec.

Returns

A Vec<ConditionalOrderParams> containing all orders that were managed by this multiplexer, in insertion order.

pub fn to_json(&self) -> Result<String, CowError>

Serialise the multiplexer to a JSON string.

The output is a JSON object with proof_location (integer) and orders (array of { handler, salt, static_input } hex strings). Deserialise with Multiplexer::from_json.

Errors

Returns CowError::AppData if serialisation fails.

pub fn decode_proofs_from_json( json: &str, ) -> Result<Vec<ProofWithParams>, CowError>

Decode a watchtower proof array from the JSON format used by the CoW Protocol watchtower service.

The input must be a JSON array of { "proof": ["0x...", ...], "params": { "handler": "0x...", "salt": "0x...", "staticInput": "0x..." } } objects.

Errors

Returns CowError::AppData on parse or hex-decode failure.

pub fn from_json(json: &str) -> Result<Self, CowError>

Deserialise a Multiplexer from a JSON string produced by Multiplexer::to_json.

Errors

Returns CowError::AppData on parse or decode failure.

Trait Implementations

impl Clone for Multiplexer

fn clone(&self) -> Multiplexer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Multiplexer

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

Formats the value using the given formatter.

impl Default for Multiplexer

fn default() -> Multiplexer

Returns the “default value” for a type.

impl Display for Multiplexer

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

Formats the value using the given formatter.