Orders accounting

Cargo.toml

@@ -34,6 +34,7 @@ members = [
   "networking",                         # Pure networking implementations
   "node-gui",                           # Node GUI binary.
   "node-lib",                           # Node lib; the common library between daemon, tui and gui node executables.
+  "orders-accounting",                  # Orders accounting
   "p2p",                                # P2p communication interfaces and protocols.
   "p2p/backend-test-suite",             # P2p backend agnostic tests.
   "p2p/types",                          # P2p support types with minimal dependencies.

api-server/scanner-lib/Cargo.toml

@@ -15,6 +15,7 @@ constraints-value-accumulator = { path = "../../chainstate/constraints-value-acc
 logging = { path = "../../logging" }
 mempool = { path = "../../mempool" }
 node-comm = { path = "../../wallet/wallet-node-client" }
+orders-accounting = { path = "../../orders-accounting" }
 pos-accounting = { path = "../../pos-accounting" }
 randomness = { path = "../../randomness" }
 utils = { path = "../../utils" }

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

@@ -396,7 +396,8 @@ async fn update_tables_from_block_reward<T: ApiServerStorageWrite>(
             | TxOutput::DelegateStaking(_, _)
             | TxOutput::IssueFungibleToken(_)
             | TxOutput::IssueNft(_, _, _)
-            | TxOutput::Htlc(_, _) => {}
+            | TxOutput::Htlc(_, _)
+            | TxOutput::AnyoneCanTake(_) => {}
             TxOutput::ProduceBlockFromStake(_, _) => {
                 set_utxo(
                     outpoint,
@@ -571,7 +572,8 @@ async fn calculate_fees<T: ApiServerStorageWrite>(
                 | TxOutput::DelegateStaking(_, _)
                 | TxOutput::CreateDelegationId(_, _)
                 | TxOutput::ProduceBlockFromStake(_, _)
-                | TxOutput::Htlc(_, _) => None,
+                | TxOutput::Htlc(_, _)
+                | TxOutput::AnyoneCanTake(_) => None,
             })
         })
         .collect();
@@ -604,7 +606,8 @@ async fn calculate_fees<T: ApiServerStorageWrite>(
                     | TxOutput::CreateDelegationId(_, _)
                     | TxOutput::IssueFungibleToken(_)
                     | TxOutput::ProduceBlockFromStake(_, _)
-                    | TxOutput::Htlc(_, _) => None,
+                    | TxOutput::Htlc(_, _)
+                    | TxOutput::AnyoneCanTake(_) => None,
                 },
                 TxInput::Account(_) => None,
                 TxInput::AccountCommand(_, cmd) => match cmd {
@@ -614,6 +617,7 @@ async fn calculate_fees<T: ApiServerStorageWrite>(
                     | AccountCommand::UnfreezeToken(token_id)
                     | AccountCommand::LockTokenSupply(token_id)
                     | AccountCommand::ChangeTokenAuthority(token_id, _) => Some(*token_id),
+                    AccountCommand::CancelOrder(_) | AccountCommand::FillOrder(_, _, _) => None,
                 },
             })
             .collect();
@@ -672,6 +676,56 @@ async fn token_decimals<T: ApiServerStorageRead>(
     Ok((token_id, decimals))
 }
 
+struct PoSAccountingAdapterToCheckFees {
+    pools: BTreeMap<PoolId, PoolData>,
+}
+
+impl PoSAccountingView for PoSAccountingAdapterToCheckFees {
+    type Error = pos_accounting::Error;
+
+    fn pool_exists(&self, _pool_id: PoolId) -> Result<bool, Self::Error> {
+        unimplemented!()
+    }
+
+    fn get_pool_balance(&self, _pool_id: PoolId) -> Result<Option<Amount>, Self::Error> {
+        unimplemented!()
+    }
+
+    fn get_pool_data(&self, pool_id: PoolId) -> Result<Option<PoolData>, Self::Error> {
+        Ok(self.pools.get(&pool_id).cloned())
+    }
+
+    fn get_pool_delegations_shares(
+        &self,
+        _pool_id: PoolId,
+    ) -> Result<Option<BTreeMap<DelegationId, Amount>>, Self::Error> {
+        unimplemented!()
+    }
+
+    fn get_delegation_balance(
+        &self,
+        _delegation_id: DelegationId,
+    ) -> Result<Option<Amount>, Self::Error> {
+        // only used for checks for attempted to print money but we don't need to check that here
+        Ok(Some(Amount::MAX))
+    }
+
+    fn get_delegation_data(
+        &self,
+        _delegation_id: DelegationId,
+    ) -> Result<Option<pos_accounting::DelegationData>, Self::Error> {
+        unimplemented!()
+    }
+
+    fn get_pool_delegation_share(
+        &self,
+        _pool_id: PoolId,
+        _delegation_id: DelegationId,
+    ) -> Result<Option<Amount>, Self::Error> {
+        unimplemented!()
+    }
+}
+
 async fn tx_fees<T: ApiServerStorageWrite>(
     chain_config: &ChainConfig,
     block_height: BlockHeight,
@@ -680,17 +734,18 @@ async fn tx_fees<T: ApiServerStorageWrite>(
     new_outputs: &BTreeMap<UtxoOutPoint, &TxOutput>,
 ) -> Result<AccumulatedFee, ApiServerStorageError> {
     let inputs_utxos = collect_inputs_utxos(db_tx, tx.inputs(), new_outputs).await?;
-    let pools = prefetch_pool_amounts(&inputs_utxos, db_tx).await?;
+    let pools = prefetch_pool_data(&inputs_utxos, db_tx).await?;
+    let pos_accounting_adapter = PoSAccountingAdapterToCheckFees { pools };
 
-    let staker_balance_getter = |pool_id: PoolId| Ok(pools.get(&pool_id).cloned());
-    // only used for checks for attempted to print money but we don't need to check that here
-    let delegation_balance_getter = |_delegation_id: DelegationId| Ok(Some(Amount::MAX));
+    // TODO(orders)
+    let orders_store = orders_accounting::InMemoryOrdersAccounting::new();
+    let orders_db = orders_accounting::OrdersAccountingDB::new(&orders_store);
 
     let inputs_accumulator = ConstrainedValueAccumulator::from_inputs(
         chain_config,
         block_height,
-        staker_balance_getter,
-        delegation_balance_getter,
+        &orders_db,
+        &pos_accounting_adapter,
         tx.inputs(),
         &inputs_utxos,
     )
@@ -703,23 +758,18 @@ async fn tx_fees<T: ApiServerStorageWrite>(
     Ok(consumed_accumulator)
 }
 
-async fn prefetch_pool_amounts<T: ApiServerStorageWrite>(
+async fn prefetch_pool_data<T: ApiServerStorageWrite>(
     inputs_utxos: &Vec<Option<TxOutput>>,
     db_tx: &mut T,
-) -> Result<BTreeMap<PoolId, Amount>, ApiServerStorageError> {
+) -> Result<BTreeMap<PoolId, PoolData>, ApiServerStorageError> {
     let mut pools = BTreeMap::new();
     for output in inputs_utxos {
         match output {
             Some(
                 TxOutput::CreateStakePool(pool_id, _) | TxOutput::ProduceBlockFromStake(_, pool_id),
             ) => {
-                let amount = db_tx
-                    .get_pool_data(*pool_id)
-                    .await?
-                    .expect("should exist")
-                    .staker_balance()
-                    .expect("no overflow");
-                pools.insert(*pool_id, amount);
+                let data = db_tx.get_pool_data(*pool_id).await?.expect("should exist");
+                pools.insert(*pool_id, data);
             }
             Some(
                 TxOutput::Burn(_)
@@ -730,7 +780,8 @@ async fn prefetch_pool_amounts<T: ApiServerStorageWrite>(
                 | TxOutput::DelegateStaking(_, _)
                 | TxOutput::IssueNft(_, _, _)
                 | TxOutput::IssueFungibleToken(_)
-                | TxOutput::Htlc(_, _),
+                | TxOutput::Htlc(_, _)
+                | TxOutput::AnyoneCanTake(_),
             ) => {}
             None => {}
         }
@@ -1055,6 +1106,9 @@ async fn update_tables_from_transaction_inputs<T: ApiServerStorageWrite>(
                     )
                     .await;
                 }
+                AccountCommand::CancelOrder(_) | AccountCommand::FillOrder(_, _, _) => {
+                    // TODO(orders)
+                }
             },
             TxInput::Account(outpoint) => {
                 match outpoint.account() {
@@ -1108,7 +1162,8 @@ async fn update_tables_from_transaction_inputs<T: ApiServerStorageWrite>(
                         | TxOutput::CreateDelegationId(_, _)
                         | TxOutput::DelegateStaking(_, _)
                         | TxOutput::IssueFungibleToken(_)
-                        | TxOutput::Htlc(_, _) => {}
+                        | TxOutput::Htlc(_, _)
+                        | TxOutput::AnyoneCanTake(_) => {}
                         TxOutput::CreateStakePool(pool_id, _)
                         | TxOutput::ProduceBlockFromStake(_, pool_id) => {
                             let pool_data = db_tx
@@ -1161,8 +1216,9 @@ async fn update_tables_from_transaction_inputs<T: ApiServerStorageWrite>(
                         | TxOutput::CreateDelegationId(_, _)
                         | TxOutput::DelegateStaking(_, _)
                         | TxOutput::DataDeposit(_)
-                        | TxOutput::IssueFungibleToken(_) => {}
-                        | TxOutput::CreateStakePool(pool_id, _)
+                        | TxOutput::IssueFungibleToken(_)
+                        | TxOutput::AnyoneCanTake(_) => {}
+                        TxOutput::CreateStakePool(pool_id, _)
                         | TxOutput::ProduceBlockFromStake(_, pool_id) => {
                             let pool_data = db_tx
                                 .get_pool_data(pool_id)
@@ -1464,7 +1520,7 @@ async fn update_tables_from_transaction_outputs<T: ApiServerStorageWrite>(
                         .expect("Unable to encode address");
                 address_transactions.entry(staker_address).or_default().insert(transaction_id);
             }
-            | TxOutput::DelegateStaking(amount, delegation_id) => {
+            TxOutput::DelegateStaking(amount, delegation_id) => {
                 // Update delegation pledge
 
                 let delegation = db_tx
@@ -1617,6 +1673,9 @@ async fn update_tables_from_transaction_outputs<T: ApiServerStorageWrite>(
                 }
             }
             TxOutput::Htlc(_, _) => {} // TODO(HTLC)
+            TxOutput::AnyoneCanTake(_) => {
+                // TODO(orders)
+            }
         }
     }
 
@@ -1815,7 +1874,8 @@ fn get_tx_output_destination(txo: &TxOutput) -> Option<&Destination> {
         TxOutput::IssueFungibleToken(_)
         | TxOutput::Burn(_)
         | TxOutput::DelegateStaking(_, _)
-        | TxOutput::DataDeposit(_) => None,
+        | TxOutput::DataDeposit(_)
+        | TxOutput::AnyoneCanTake(_) => None,
         TxOutput::Htlc(_, _) => None, // TODO(HTLC)
     }
 }