Struct FullOrder 

pub struct FullOrder {
    pub nonce: u64,
    pub maker: Pubkey,
    pub market: Pubkey,
    pub base_mint: Pubkey,
    pub quote_mint: Pubkey,
    pub side: OrderSide,
    pub maker_amount: u64,
    pub taker_amount: u64,
    pub expiration: i64,
    pub signature: [u8; 64],
}

Full order structure with signature.

Layout (225 bytes):

• [0..8] nonce (8 bytes)
• [8..40] maker (32 bytes)
• [40..72] market (32 bytes)
• [72..104] base_mint (32 bytes)
• [104..136] quote_mint (32 bytes)
• [136] side (1 byte)
• [137..145] maker_amount (8 bytes)
• [145..153] taker_amount (8 bytes)
• [153..161] expiration (8 bytes)
• [161..225] signature (64 bytes)

Fields

nonce: u64

Unique order ID and replay protection

maker: Pubkey

Order maker’s pubkey

market: Pubkey

Market pubkey

base_mint: Pubkey

Base mint (token being bought/sold)

quote_mint: Pubkey

Quote mint (token used for payment)

side: OrderSide

Order side (0 = Bid, 1 = Ask)

maker_amount: u64

Amount maker gives

taker_amount: u64

Amount maker receives

expiration: i64

Expiration timestamp (0 = no expiration)

signature: [u8; 64]

Ed25519 signature

Implementations

impl FullOrder

pub const LEN: usize = FULL_ORDER_SIZE

Order size in bytes

pub fn new_bid(params: BidOrderParams) -> Self

Create a new bid order (maker buys base, gives quote)

pub fn new_ask(params: AskOrderParams) -> Self

Create a new ask order (maker sells base, receives quote)

pub fn hash(&self) -> [u8; 32]

Compute the Keccak256 hash of the order (excludes signature).

Hash layout (161 bytes):

• nonce (8)
• maker (32)
• market (32)
• base_mint (32)
• quote_mint (32)
• side (1)
• maker_amount (8)
• taker_amount (8)
• expiration (8)

pub fn sign(&mut self, keypair: &Keypair)

Sign the order with the given keypair.

pub fn new_bid_signed(params: BidOrderParams, keypair: &Keypair) -> Self

Create and sign an order in one step.

pub fn new_ask_signed(params: AskOrderParams, keypair: &Keypair) -> Self

Create and sign an ask order in one step.

pub fn verify_signature(&self) -> SdkResult<bool>

Verify the signature against the maker’s pubkey.

pub fn serialize(&self) -> [u8; 225]

Serialize to bytes (225 bytes).

pub fn deserialize(data: &[u8]) -> SdkResult<Self>

Deserialize from bytes.

pub fn to_compact(&self) -> CompactOrder

Convert to compact order format.

pub fn to_submit_request( &self, orderbook_id: impl Into<String>, ) -> SubmitOrderRequest

Convert a signed order to an API SubmitOrderRequest.

This bridges on-chain order creation with REST API submission.

Arguments

• orderbook_id - Target orderbook (get from market API or use derive_orderbook_id())

Panics

Panics if the order has not been signed (signature is all zeros).

Example

let mut order = FullOrder::new_bid(params);
order.sign(&keypair);

let request = order.to_submit_request(order.derive_orderbook_id());
let response = api_client.submit_order(request).await?;

pub fn derive_orderbook_id(&self) -> String

Derive the orderbook ID for this order.

Format: {base_token[0:8]}_{quote_token[0:8]}

pub fn signature_hex(&self) -> String

Get the signature as a hex string (128 chars).

pub fn hash_hex(&self) -> String

Get the order hash as a hex string (64 chars).

pub fn is_signed(&self) -> bool

Check if the order has been signed.

Trait Implementations

impl Clone for FullOrder

fn clone(&self) -> FullOrder

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FullOrder

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

Formats the value using the given formatter.