Introduce TxInput::OrderAccountCommand without nonces

api-server/api-server-common/src/storage/storage_api/mod.rs

@@ -194,10 +194,24 @@ pub struct Order {
 }
 
 impl Order {
-    pub fn fill(self, fill_amount_in_ask_currency: Amount) -> Self {
+    pub fn fill(
+        self,
+        chain_config: &ChainConfig,
+        block_height: BlockHeight,
+        fill_amount_in_ask_currency: Amount,
+    ) -> Self {
+        let (ask_balance, give_balance) = match chain_config
+            .chainstate_upgrades()
+            .version_at_height(block_height)
+            .1
+            .orders_version()
+        {
+            common::chain::OrdersVersion::V0 => (self.ask_balance, self.give_balance),
+            common::chain::OrdersVersion::V1 => (self.initially_asked, self.initially_given),
+        };
         let filled_amount = orders_accounting::calculate_filled_amount(
-            self.ask_balance,
-            self.give_balance,
+            ask_balance,
+            give_balance,
             fill_amount_in_ask_currency,
         )
         .expect("must succeed");

api-server/scanner-lib/src/blockchain_state/mod.rs

@@ -34,8 +34,8 @@ use common::{
         tokens::{get_referenced_token_ids, make_token_id, IsTokenFrozen, TokenId, TokenIssuance},
         transaction::OutPointSourceId,
         AccountCommand, AccountNonce, AccountSpending, Block, DelegationId, Destination, GenBlock,
-        Genesis, OrderData, OrderId, PoolId, SignedTransaction, Transaction, TxInput, TxOutput,
-        UtxoOutPoint,
+        Genesis, OrderAccountCommand, OrderData, OrderId, PoolId, SignedTransaction, Transaction,
+        TxInput, TxOutput, UtxoOutPoint,
     },
     primitives::{id::WithId, Amount, BlockHeight, CoinOrTokenId, Fee, Id, Idable, H256},
 };
@@ -631,6 +631,28 @@ async fn calculate_tx_fee_and_collect_token_info<T: ApiServerStorageWrite>(
                         };
                     }
                 },
+                TxInput::OrderAccountCommand(cmd) => match cmd {
+                    OrderAccountCommand::FillOrder(order_id, _, _)
+                    | OrderAccountCommand::ConcludeOrder {
+                        order_id,
+                        filled_amount: _,
+                        remaining_give_amount: _,
+                    } => {
+                        let order = db_tx.get_order(*order_id).await?.expect("must exist");
+                        match order.ask_currency {
+                            CoinOrTokenId::Coin => {}
+                            CoinOrTokenId::TokenId(id) => {
+                                token_ids.insert(id);
+                            }
+                        };
+                        match order.give_currency {
+                            CoinOrTokenId::Coin => {}
+                            CoinOrTokenId::TokenId(id) => {
+                                token_ids.insert(id);
+                            }
+                        };
+                    }
+                },
             };
         }
 
@@ -675,7 +697,9 @@ async fn fetch_utxo<T: ApiServerStorageRead>(
                 .expect("must be present");
             Ok(Some(utxo))
         }
-        TxInput::Account(_) | TxInput::AccountCommand(_, _) => Ok(None),
+        TxInput::Account(_) | TxInput::AccountCommand(_, _) | TxInput::OrderAccountCommand(_) => {
+            Ok(None)
+        }
     }
 }
 
@@ -842,9 +866,40 @@ async fn prefetch_orders<T: ApiServerStorageRead>(
     let mut ask_balances = BTreeMap::<OrderId, Amount>::new();
     let mut give_balances = BTreeMap::<OrderId, Amount>::new();
 
+    let to_order_data = |order: &Order| {
+        let ask = match order.ask_currency {
+            CoinOrTokenId::Coin => OutputValue::Coin(order.initially_asked),
+            CoinOrTokenId::TokenId(token_id) => {
+                OutputValue::TokenV1(token_id, order.initially_asked)
+            }
+        };
+        let give = match order.give_currency {
+            CoinOrTokenId::Coin => OutputValue::Coin(order.initially_given),
+            CoinOrTokenId::TokenId(token_id) => {
+                OutputValue::TokenV1(token_id, order.initially_given)
+            }
+        };
+        OrderData::new(order.conclude_destination.clone(), ask, give)
+    };
+
     for input in inputs {
         match input {
             TxInput::Utxo(_) | TxInput::Account(_) => {}
+            TxInput::OrderAccountCommand(cmd) => match cmd {
+                OrderAccountCommand::FillOrder(order_id, _, _)
+                | OrderAccountCommand::ConcludeOrder {
+                    order_id,
+                    filled_amount: _,
+                    remaining_give_amount: _,
+                } => {
+                    let order = db_tx.get_order(*order_id).await?.expect("must be present ");
+                    let order_data = to_order_data(&order);
+
+                    ask_balances.insert(*order_id, order.ask_balance);
+                    give_balances.insert(*order_id, order.give_balance);
+                    orders_data.insert(*order_id, order_data);
+                }
+            },
             TxInput::AccountCommand(_, account_command) => match account_command {
                 AccountCommand::MintTokens(_, _)
                 | AccountCommand::UnmintTokens(_)
@@ -856,21 +911,10 @@ async fn prefetch_orders<T: ApiServerStorageRead>(
                 AccountCommand::FillOrder(order_id, _, _)
                 | AccountCommand::ConcludeOrder(order_id) => {
                     let order = db_tx.get_order(*order_id).await?.expect("must be present ");
+                    let order_data = to_order_data(&order);
+
                     ask_balances.insert(*order_id, order.ask_balance);
                     give_balances.insert(*order_id, order.give_balance);
-                    let ask = match order.ask_currency {
-                        CoinOrTokenId::Coin => OutputValue::Coin(order.initially_asked),
-                        CoinOrTokenId::TokenId(token_id) => {
-                            OutputValue::TokenV1(token_id, order.initially_asked)
-                        }
-                    };
-                    let give = match order.give_currency {
-                        CoinOrTokenId::Coin => OutputValue::Coin(order.initially_given),
-                        CoinOrTokenId::TokenId(token_id) => {
-                            OutputValue::TokenV1(token_id, order.initially_given)
-                        }
-                    };
-                    let order_data = OrderData::new(order.conclude_destination.clone(), ask, give);
                     orders_data.insert(*order_id, order_data);
                 }
             },
@@ -922,7 +966,9 @@ async fn update_tables_from_consensus_data<T: ApiServerStorageWrite>(
                         )
                         .await;
                     }
-                    TxInput::Account(_) | TxInput::AccountCommand(_, _) => {}
+                    TxInput::Account(_)
+                    | TxInput::AccountCommand(_, _)
+                    | TxInput::OrderAccountCommand(_) => {}
                 }
             }
 
@@ -1215,7 +1261,8 @@ async fn update_tables_from_transaction_inputs<T: ApiServerStorageWrite>(
                 }
                 AccountCommand::FillOrder(order_id, fill_amount_in_ask_currency, _) => {
                     let order = db_tx.get_order(*order_id).await?.expect("must exist");
-                    let order = order.fill(*fill_amount_in_ask_currency);
+                    let order =
+                        order.fill(&chain_config, block_height, *fill_amount_in_ask_currency);
 
                     db_tx.set_order_at_height(*order_id, &order, block_height).await?;
                 }
@@ -1226,6 +1273,25 @@ async fn update_tables_from_transaction_inputs<T: ApiServerStorageWrite>(
                     db_tx.set_order_at_height(*order_id, &order, block_height).await?;
                 }
             },
+            TxInput::OrderAccountCommand(cmd) => match cmd {
+                OrderAccountCommand::FillOrder(order_id, fill_amount_in_ask_currency, _) => {
+                    let order = db_tx.get_order(*order_id).await?.expect("must exist");
+                    let order =
+                        order.fill(&chain_config, block_height, *fill_amount_in_ask_currency);
+
+                    db_tx.set_order_at_height(*order_id, &order, block_height).await?;
+                }
+                OrderAccountCommand::ConcludeOrder {
+                    order_id,
+                    filled_amount: _,
+                    remaining_give_amount: _,
+                } => {
+                    let order = db_tx.get_order(*order_id).await?.expect("must exist");
+                    let order = order.conclude();
+
+                    db_tx.set_order_at_height(*order_id, &order, block_height).await?;
+                }
+            },
             TxInput::Account(outpoint) => {
                 match outpoint.account() {
                     AccountSpending::DelegationBalance(delegation_id, amount) => {

api-server/scanner-lib/src/sync/tests/simulation.rs

@@ -646,6 +646,7 @@ fn update_statistics(
             }
             AccountCommand::ConcludeOrder(_) | AccountCommand::FillOrder(_, _, _) => {}
         },
+        TxInput::OrderAccountCommand(..) => {}
     });
 }
 

api-server/stack-test-suite/tests/v2/block.rs

@@ -279,7 +279,9 @@ async fn get_tx_additional_data(
                 TxInput::Utxo(outpoint) => {
                     db_tx.get_utxo(outpoint.clone()).await.unwrap().map(|utxo| utxo.into_output())
                 }
-                TxInput::Account(_) | TxInput::AccountCommand(_, _) => None,
+                TxInput::Account(_)
+                | TxInput::AccountCommand(_, _)
+                | TxInput::OrderAccountCommand(_) => None,
             };
             input_utxos.push(utxo);
         }

api-server/stack-test-suite/tests/v2/orders.rs

@@ -13,7 +13,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use common::chain::{make_order_id, AccountCommand, AccountNonce, OrderData};
+use common::chain::{make_order_id, OrderAccountCommand, OrderData};
 
 use super::*;
 
@@ -68,14 +68,11 @@ async fn create_fill_conclude_order(#[case] seed: Seed) {
                         InputWitness::NoSignature(None),
                     )
                     .add_input(
-                        TxInput::AccountCommand(
-                            AccountNonce::new(0),
-                            AccountCommand::FillOrder(
-                                order_id,
-                                Amount::from_atoms(1),
-                                Destination::AnyoneCanSpend,
-                            ),
-                        ),
+                        TxInput::OrderAccountCommand(OrderAccountCommand::FillOrder(
+                            order_id,
+                            Amount::from_atoms(1),
+                            Destination::AnyoneCanSpend,
+                        )),
                         InputWitness::NoSignature(None),
                     )
                     .add_output(TxOutput::Transfer(
@@ -91,10 +88,11 @@ async fn create_fill_conclude_order(#[case] seed: Seed) {
                 // Conclude order
                 let tx3 = TransactionBuilder::new()
                     .add_input(
-                        TxInput::AccountCommand(
-                            AccountNonce::new(1),
-                            AccountCommand::ConcludeOrder(order_id),
-                        ),
+                        TxInput::OrderAccountCommand(OrderAccountCommand::ConcludeOrder {
+                            order_id,
+                            filled_amount: Amount::from_atoms(1),
+                            remaining_give_amount: Amount::from_atoms(9),
+                        }),
                         InputWitness::NoSignature(None),
                     )
                     .add_output(TxOutput::Transfer(

api-server/stack-test-suite/tests/v2/transaction.rs

@@ -181,7 +181,9 @@ async fn multiple_tx_in_same_block(#[case] seed: Seed) {
                     TxInput::Utxo(outpoint) => {
                         Some(signed_tx1.outputs()[outpoint.output_index() as usize].clone())
                     }
-                    TxInput::Account(_) | TxInput::AccountCommand(_, _) => None,
+                    TxInput::Account(_)
+                    | TxInput::AccountCommand(_, _)
+                    | TxInput::OrderAccountCommand(_) => None,
                 });
 
                 let transaction = signed_tx2.transaction();
@@ -327,7 +329,9 @@ async fn ok(#[case] seed: Seed) {
                     TxInput::Utxo(outpoint) => {
                         Some(prev_tx.outputs()[outpoint.output_index() as usize].clone())
                     }
-                    TxInput::Account(_) | TxInput::AccountCommand(_, _) => None,
+                    TxInput::Account(_)
+                    | TxInput::AccountCommand(_, _)
+                    | TxInput::OrderAccountCommand(_) => None,
                 });
 
                 let expected_transaction = json!({

api-server/stack-test-suite/tests/v2/transactions.rs

@@ -116,7 +116,9 @@ async fn ok(#[case] seed: Seed) {
                                 TxInput::Utxo(outpoint) => Some(
                                     prev_tx.outputs()[outpoint.output_index() as usize].clone(),
                                 ),
-                                TxInput::Account(_) | TxInput::AccountCommand(_, _) => None,
+                                TxInput::Account(_)
+                                | TxInput::AccountCommand(_, _)
+                                | TxInput::OrderAccountCommand(_) => None,
                             })
                             .collect();
 

api-server/storage-test-suite/src/basic.rs

@@ -1430,6 +1430,7 @@ async fn orders<'a, S: for<'b> Transactional<'b>>(
     rng: &mut (impl Rng + CryptoRng),
     storage: &'a mut S,
 ) {
+    let chain_config = common::chain::config::create_regtest();
     {
         let db_tx = storage.transaction_ro().await.unwrap();
         let random_order_id = OrderId::new(H256::random_using(rng));
@@ -1542,7 +1543,7 @@ async fn orders<'a, S: for<'b> Transactional<'b>>(
     );
 
     // Fill one order
-    let order2_filled = order2.clone().fill(Amount::from_atoms(1));
+    let order2_filled = order2.clone().fill(&chain_config, block_height, Amount::from_atoms(1));
     db_tx
         .set_order_at_height(order2_id, &order2_filled, block_height.next_height())
         .await

api-server/web-server/src/api/json_helpers.rs

@@ -24,8 +24,8 @@ use common::{
         block::ConsensusData,
         output_value::OutputValue,
         tokens::{IsTokenUnfreezable, NftIssuance, TokenId, TokenTotalSupply},
-        AccountCommand, AccountSpending, Block, ChainConfig, Destination, OrderId,
-        OutPointSourceId, Transaction, TxInput, TxOutput, UtxoOutPoint,
+        AccountCommand, AccountSpending, Block, ChainConfig, Destination, OrderAccountCommand,
+        OrderId, OutPointSourceId, Transaction, TxInput, TxOutput, UtxoOutPoint,
     },
     primitives::{Amount, BlockHeight, CoinOrTokenId, Idable},
     Uint256,
@@ -318,6 +318,30 @@ pub fn tx_input_to_json(inp: &TxInput, chain_config: &ChainConfig) -> serde_json
                 })
             }
         },
+        TxInput::OrderAccountCommand(cmd) => match cmd {
+            OrderAccountCommand::FillOrder(id, fill, dest) => {
+                json!({
+                    "input_type": "OrderAccountCommand",
+                    "command": "FillOrder",
+                    "order_id": Address::new(chain_config, *id).expect("addressable").to_string(),
+                    "fill_atoms": json!({"atoms": fill.into_atoms().to_string()}),
+                    "destination": Address::new(chain_config, dest.clone()).expect("no error").as_str(),
+                })
+            }
+            OrderAccountCommand::ConcludeOrder {
+                order_id,
+                filled_amount,
+                remaining_give_amount,
+            } => {
+                json!({
+                    "input_type": "OrderAccountCommand",
+                    "command": "ConcludeOrder",
+                    "order_id": Address::new(chain_config, *order_id).expect("addressable").to_string(),
+                    "filled_atoms": json!({"atoms": filled_amount.into_atoms().to_string()}),
+                    "remaining_give_atoms": json!({"atoms": remaining_give_amount.into_atoms().to_string()}),
+                })
+            }
+        },
         TxInput::AccountCommand(nonce, cmd) => match cmd {
             AccountCommand::MintTokens(token_id, amount) => {
                 json!({