Struct SignedOrder

pub struct SignedOrder {
    pub permit: Permit2Batch,
    pub outputs: Vec<Output>,
}

A SignedOrder represents a single Order after it has been permit2-encoded and signed. It is the final format signed by Users and shared with Fillers to request that an Order be filled.

It corresponds to the parameters for initiatePermit2 on the OrderOrigin contract, and thus contains all necessary information to initiate the Order.

It can be shared with all Fillers via the Signet Node signet_sendOrder RPC call, or shared directly with specific Filler(s) via private channels. The type can be signed and published safely, because although the Permit2Batch allows the Order Inputs to be transferred from the user, the Signet Node ensures that Inputs cannot be transferred until the Order Outputs have already been filled.

TODO: Link to docs.

Fields

permit: Permit2Batch

The permit batch.

outputs: Vec<Output>

The desired outputs.

Implementations

impl SignedOrder

pub const fn new(permit: Permit2Batch, outputs: Vec<Output>) -> Self

Creates a new signed order.

pub fn validate(&self, timestamp: u64) -> Result<(), SignedPermitError>

Check that this can be syntactically used to initiate an order.

For it to be valid:

• Deadline must be in the future.

pub fn to_initiate_tx( &self, filler_token_recipient: Address, order_contract: Address, ) -> TransactionRequest

Generate a TransactionRequest to initiate the SignedOrder.

Trait Implementations

impl Clone for SignedOrder

fn clone(&self) -> SignedOrder

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SignedOrder

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SignedOrder

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> From<&'a SignedOrder> for AggregateOrders

fn from(order: &'a SignedOrder) -> Self

Converts to this type from the input type.

impl<'a> FromIterator<&'a SignedOrder> for AggregateOrders

fn from_iter<T: IntoIterator<Item = &'a SignedOrder>>(iter: T) -> Self

Creates a value from an iterator.

impl PartialEq for SignedOrder

fn eq(&self, other: &SignedOrder) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for SignedOrder

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for SignedOrder

impl StructuralPartialEq for SignedOrder