Struct SignedOrder 

pub struct SignedOrder { /* private fields */ }

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.

Implementations

impl SignedOrder

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

Creates a new signed order.

pub const fn permit(&self) -> &Permit2Batch

Get the permit batch.

pub fn outputs(&self) -> &[Output]

Get the outputs.

pub fn into_parts(self) -> (Permit2Batch, Vec<Output>)

Decompose the SignedOrder into its parts.

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.

pub fn order_hash(&self) -> &B256

Get the hash of the order.

Composition

The order hash is composed of the following:

• The permit2 batch permit inputs, ABI encoded and hashed.
• The permit2 batch owner, ABI encoded and hashed.
• The order outputs, ABI encoded and hashed.
• The permit2 batch signature, normalized and hashed.

The components are then hashed together.

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