Reworks the Buy/Sell order api to support creating multiple identical…

… positions.

This is especially useful for limit orders because it allows them to be filled piece wise.

crates/bin/pcli/src/command/tx.rs

@@ -954,22 +954,30 @@ impl TxCmd {
 
                 tracing::info!(?order);
                 let source = AddressIndex::new(order.source());
-                let position = order.as_position(&asset_cache, OsRng)?;
-                tracing::info!(?position);
-
-                println!("Position id: {}", position.id());
+                let positions = order.as_position(&asset_cache)?;
+                tracing::info!(?positions);
+                for position in &positions {
+                    println!("Position id: {}", position.id());
+                }
 
-                let plan = Planner::new(OsRng)
+                let mut planner = Planner::new(OsRng);
+                planner
                     .set_gas_prices(gas_prices)
-                    .set_fee_tier(order.fee_tier().into())
-                    .position_open(position)
+                    .set_fee_tier(order.fee_tier().into());
+
+                for position in positions {
+                    planner.position_open(position);
+                }
+
+                let plan = planner
                     .plan(
                         app.view
                             .as_mut()
                             .context("view service must be initialized")?,
                         source,
                     )
                     .await?;
+
                 app.build_and_submit_transaction(plan).await?;
             }
             TxCmd::Withdraw {

crates/bin/pcli/src/command/tx/liquidity_position.rs

@@ -8,7 +8,7 @@ use penumbra_dex::{
     },
     TradingPair,
 };
-use rand_core::CryptoRngCore;
+use rand_core::OsRng;
 
 use super::{replicate::ReplicateCmd, FeeTier};
 
@@ -104,6 +104,9 @@ pub enum OrderCmd {
         /// The selected fee tier to multiply the fee amount by.
         #[clap(short, long, default_value_t)]
         fee_tier: FeeTier,
+        /// Duplicate the order for the given number of times.
+        #[clap(short, long, default_value = "1")]
+        duplicate: u32,
     },
     Sell {
         /// The desired sale, formatted as a string, e.g. `[email protected]` would attempt
@@ -121,6 +124,9 @@ pub enum OrderCmd {
         /// The selected fee tier to multiply the fee amount by.
         #[clap(short, long, default_value_t)]
         fee_tier: FeeTier,
+        /// Duplicate the order for the given number of times.
+        #[clap(short, long, default_value = "1")]
+        duplicate: u32,
     },
 }
 
@@ -146,30 +152,48 @@ impl OrderCmd {
         }
     }
 
-    pub fn as_position<R: CryptoRngCore>(
+    pub fn duplicate(&self) -> u32 {
+        match self {
+            OrderCmd::Buy { duplicate, .. } => *duplicate,
+            OrderCmd::Sell { duplicate, .. } => *duplicate,
+        }
+    }
+
+    pub fn as_position(
         &self,
         // Preserved since we'll need it after denom metadata refactor
         _asset_cache: &asset::Cache,
-        rng: R,
-    ) -> Result<Position> {
-        let mut position = match self {
+    ) -> Result<Vec<Position>> {
+        let positions = match self {
             OrderCmd::Buy { buy_order, .. } => {
                 tracing::info!(?buy_order, "parsing buy order");
                 let order = BuyOrder::parse_str(buy_order)?;
-                order.into_position(rng)
+                let mut positions = Vec::new();
+                for _ in 0..self.duplicate() {
+                    let mut position = order.into_position(OsRng);
+                    if self.is_auto_closing() {
+                        position.close_on_fill = true;
+                    }
+                    positions.push(position);
+                }
+                positions
             }
             OrderCmd::Sell { sell_order, .. } => {
                 tracing::info!(?sell_order, "parsing sell order");
                 let order = SellOrder::parse_str(sell_order)?;
-                order.into_position(rng)
+                let mut positions = Vec::new();
+
+                for _ in 0..self.duplicate() {
+                    let mut position = order.into_position(OsRng);
+                    if self.is_auto_closing() {
+                        position.close_on_fill = true;
+                    }
+                    positions.push(position);
+                }
+                positions
             }
         };
-        tracing::info!(?position);
-
-        if self.is_auto_closing() {
-            position.close_on_fill = true;
-        }
 
-        Ok(position)
+        Ok(positions)
     }
 }