Correct false positive about transaction atomicity in post_order

client/Cargo.toml

@@ -13,6 +13,7 @@ dropset-interface = { path = "../interface", features = ["client", "solana-progr
 itertools.workspace = true
 futures.workspace = true
 lazy-regex.workspace = true
+price = { path = "../price" }
 regex.workspace = true
 solana-client.workspace = true
 solana-commitment-config.workspace = true
@@ -28,6 +29,7 @@ solana-transaction-status-client-types.workspace = true
 spl-associated-token-account-interface.workspace = true
 spl-token-interface.workspace = true
 spl-token-2022-interface.workspace = true
+static_assertions.workspace = true
 strum.workspace = true
 strum_macros.workspace = true
 tokio.workspace = true

client/examples/post_and_cancel.rs

@@ -0,0 +1,115 @@
+use std::collections::HashSet;
+
+use client::{
+    context::market::MarketContext,
+    transactions::{
+        CustomRpcClient,
+        SendTransactionConfig,
+    },
+};
+use dropset_interface::{
+    instructions::{
+        CancelOrderInstructionData,
+        PostOrderInstructionData,
+    },
+    state::sector::NIL,
+};
+use price::{
+    to_biased_exponent,
+    to_order_info,
+};
+use solana_sdk::signer::Signer;
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let rpc = &CustomRpcClient::new(
+        None,
+        Some(SendTransactionConfig {
+            compute_budget: Some(2000000),
+            debug_logs: Some(true),
+            program_id_filter: HashSet::from([dropset_interface::program::ID.into()]),
+        }),
+    );
+    let payer = rpc.fund_new_account().await?;
+
+    let market_ctx = MarketContext::new_market(rpc).await?;
+    let register = market_ctx.register_market(payer.pubkey(), 10);
+
+    market_ctx.base.create_ata_for(rpc, &payer).await?;
+    market_ctx.quote.create_ata_for(rpc, &payer).await?;
+
+    market_ctx.base.mint_to(rpc, &payer, 10000).await?;
+    market_ctx.quote.mint_to(rpc, &payer, 10000).await?;
+
+    let deposit = market_ctx.deposit_base(payer.pubkey(), 1000, NIL);
+
+    rpc.send_and_confirm_txn(&payer, &[&payer], &[register.into(), deposit.into()])
+        .await?;
+
+    let market = market_ctx.view_market(rpc)?;
+    println!("Market after user deposit\n{:#?}", market);
+
+    let user_seat = market_ctx
+        .find_seat(rpc, &payer.pubkey())?
+        .expect("User should have been registered on deposit");
+
+    let (price_mantissa, base_scalar, base_exponent, quote_exponent) = (
+        10_000_000,
+        500,
+        to_biased_exponent!(0),
+        to_biased_exponent!(0),
+    );
+    let order_info = to_order_info(price_mantissa, base_scalar, base_exponent, quote_exponent)
+        .expect("Should be a valid order");
+
+    // Post an ask. The user provides base as collateral and receives quote when filled.
+    let is_bid = false;
+    let post_ask = market_ctx.post_order(
+        payer.pubkey(),
+        PostOrderInstructionData::new(
+            price_mantissa,
+            base_scalar,
+            base_exponent,
+            quote_exponent,
+            is_bid,
+            user_seat.index,
+        ),
+    );
+
+    let res = rpc
+        .send_and_confirm_txn(&payer, &[&payer], &[post_ask.into()])
+        .await?;
+
+    println!(
+        "Post ask transaction signature: {}",
+        res.parsed_transaction.signature
+    );
+
+    let market = market_ctx.view_market(rpc)?;
+    println!("Market after posting user ask:\n{:#?}", market);
+
+    let user_seat = market_ctx.find_seat(rpc, &payer.pubkey())?.unwrap();
+    println!("User seat after posting ask: {user_seat:#?}");
+
+    let cancel_ask = market_ctx.cancel_order(
+        user_seat.user,
+        CancelOrderInstructionData::new(order_info.encoded_price.as_u32(), is_bid, user_seat.index),
+    );
+
+    let res = rpc
+        .send_and_confirm_txn(&payer, &[&payer], &[cancel_ask.into()])
+        .await?;
+
+    println!(
+        "Cancel ask transaction signature: {}",
+        res.parsed_transaction.signature
+    );
+
+    let user_seat = market_ctx.find_seat(rpc, &payer.pubkey())?.unwrap();
+    println!("User seat after canceling ask: {user_seat:#?}");
+
+    let market = market_ctx.view_market(rpc)?;
+    println!("Market after canceling user ask:\n{:#?}", market);
+
+    Ok(())
+}

client/examples/post_asks.rs

@@ -0,0 +1,118 @@
+use std::collections::HashSet;
+
+use client::{
+    context::market::MarketContext,
+    transactions::{
+        CustomRpcClient,
+        SendTransactionConfig,
+    },
+};
+use dropset_interface::{
+    instructions::PostOrderInstructionData,
+    state::sector::NIL,
+};
+use itertools::Itertools;
+use price::to_biased_exponent;
+use solana_sdk::signer::Signer;
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let rpc = &CustomRpcClient::new(
+        None,
+        Some(SendTransactionConfig {
+            compute_budget: Some(2000000),
+            debug_logs: Some(true),
+            program_id_filter: HashSet::from([dropset_interface::program::ID.into()]),
+        }),
+    );
+    let payer = rpc.fund_new_account().await?;
+
+    let market_ctx = MarketContext::new_market(rpc).await?;
+    let register = market_ctx.register_market(payer.pubkey(), 10);
+
+    market_ctx.base.create_ata_for(rpc, &payer).await?;
+    market_ctx.quote.create_ata_for(rpc, &payer).await?;
+
+    market_ctx.base.mint_to(rpc, &payer, 10000).await?;
+    market_ctx.quote.mint_to(rpc, &payer, 10000).await?;
+
+    let deposit = market_ctx.deposit_base(payer.pubkey(), 10000, NIL);
+
+    rpc.send_and_confirm_txn(&payer, &[&payer], &[register.into(), deposit.into()])
+        .await?;
+
+    let market = market_ctx.view_market(rpc)?;
+    println!("Market after user deposit\n{:#?}", market);
+
+    let user_seat = market_ctx
+        .find_seat(rpc, &payer.pubkey())?
+        .expect("User should have been registered on deposit");
+
+    let (price_mantissa, base_scalar, base_exponent, quote_exponent) = (
+        10_000_000,
+        500,
+        to_biased_exponent!(0),
+        to_biased_exponent!(0),
+    );
+
+    // Post an ask. The user provides base as collateral and receives quote when filled.
+    let is_bid = false;
+    let post_ask = market_ctx.post_order(
+        payer.pubkey(),
+        PostOrderInstructionData::new(
+            price_mantissa,
+            base_scalar,
+            base_exponent,
+            quote_exponent,
+            is_bid,
+            user_seat.index,
+        ),
+    );
+
+    let res = rpc
+        .send_and_confirm_txn(&payer, &[&payer], &[post_ask.into()])
+        .await?;
+
+    println!(
+        "Post ask transaction signature: {}",
+        res.parsed_transaction.signature
+    );
+
+    let market = market_ctx.view_market(rpc)?;
+    println!("Market after posting user ask:\n{:#?}", market);
+
+    let user_seat = market_ctx.find_seat(rpc, &payer.pubkey())?.unwrap();
+    println!("User seat after posting ask: {user_seat:#?}");
+
+    // Post an ask. The user provides base as collateral and receives quote when filled.
+    let is_bid = false;
+
+    let ask_instructions = (1..5)
+        .map(|i| {
+            market_ctx
+                .post_order(
+                    payer.pubkey(),
+                    PostOrderInstructionData::new(
+                        price_mantissa + i,
+                        base_scalar,
+                        base_exponent,
+                        quote_exponent,
+                        is_bid,
+                        user_seat.index,
+                    ),
+                )
+                .into()
+        })
+        .collect_vec();
+
+    rpc.send_and_confirm_txn(&payer, &[&payer], &ask_instructions)
+        .await?;
+
+    let market = market_ctx.view_market(rpc)?;
+    println!("Market after posting many user asks:\n{:#?}", market);
+
+    let user_seat = market_ctx.find_seat(rpc, &payer.pubkey())?.unwrap();
+    println!("User seat after posting many asks: {user_seat:#?}");
+
+    Ok(())
+}

client/src/context/market.rs

@@ -4,8 +4,10 @@
 use dropset_interface::{
     instructions::{
         generated_client::*,
+        CancelOrderInstructionData,
         CloseSeatInstructionData,
         DepositInstructionData,
+        PostOrderInstructionData,
         RegisterMarketInstructionData,
         WithdrawInstructionData,
     },
@@ -167,6 +169,38 @@ impl MarketContext {
         self.withdraw(user, data, false)
     }
 
+    pub fn post_order(
+        &self,
+        user: Pubkey,
+        data: PostOrderInstructionData,
+    ) -> SingleSignerInstruction {
+        PostOrder {
+            event_authority: event_authority::ID.into(),
+            user,
+            market_account: self.market,
+            dropset_program: dropset::ID.into(),
+        }
+        .create_instruction(data)
+        .try_into()
+        .expect("Should be a single signer instruction")
+    }
+
+    pub fn cancel_order(
+        &self,
+        user: Pubkey,
+        data: CancelOrderInstructionData,
+    ) -> SingleSignerInstruction {
+        CancelOrder {
+            event_authority: event_authority::ID.into(),
+            user,
+            market_account: self.market,
+            dropset_program: dropset::ID.into(),
+        }
+        .create_instruction(data)
+        .try_into()
+        .expect("Should be a single signer instruction")
+    }
+
     fn deposit(
         &self,
         user: Pubkey,

interface/src/error.rs

@@ -1,6 +1,7 @@
 //! Common error types and conversion helpers to represent them as error message strings.
 
 use pinocchio::program_error::ProgramError;
+use price::OrderInfoError;
 
 #[derive(Clone, Debug, Eq, PartialEq)]
 #[cfg_attr(feature = "client", derive(strum_macros::FromRepr))]
@@ -37,6 +38,12 @@ pub enum DropsetError {
     OrderWithPriceAlreadyExists,
     UserHasMaxOrders,
     OrderNotFound,
+    ExponentUnderflow,
+    ArithmeticOverflow,
+    InvalidPriceMantissa,
+    InvalidBiasedExponent,
+    InfinityIsNotAFloat,
+    PostOnlyWouldImmediatelyFill,
 }
 
 impl From<DropsetError> for ProgramError {
@@ -46,6 +53,19 @@ impl From<DropsetError> for ProgramError {
     }
 }
 
+impl From<OrderInfoError> for DropsetError {
+    #[inline(always)]
+    fn from(order_error: OrderInfoError) -> Self {
+        match order_error {
+            OrderInfoError::ExponentUnderflow => DropsetError::ExponentUnderflow,
+            OrderInfoError::ArithmeticOverflow => DropsetError::ArithmeticOverflow,
+            OrderInfoError::InvalidPriceMantissa => DropsetError::InvalidPriceMantissa,
+            OrderInfoError::InvalidBiasedExponent => DropsetError::InvalidBiasedExponent,
+            OrderInfoError::InfinityIsNotAFloat => DropsetError::InfinityIsNotAFloat,
+        }
+    }
+}
+
 impl From<DropsetError> for &'static str {
     fn from(value: DropsetError) -> Self {
         match value {
@@ -80,6 +100,12 @@ impl From<DropsetError> for &'static str {
             DropsetError::OrderWithPriceAlreadyExists => "An order with this price already exists",
             DropsetError::UserHasMaxOrders => "User already has the max number of open orders",
             DropsetError::OrderNotFound => "Order not found",
+            DropsetError::ExponentUnderflow => "Order exponent underflow",
+            DropsetError::ArithmeticOverflow => "Order arithmetic overflow",
+            DropsetError::InvalidPriceMantissa => "Invalid price mantissa in price calculation",
+            DropsetError::InvalidBiasedExponent => "Invalid biased exponent in price calculation",
+            DropsetError::InfinityIsNotAFloat => "Can't convert infinity to a float value",
+            DropsetError::PostOnlyWouldImmediatelyFill => "Post only order would immediately fill",
         }
     }
 }