Add mempool transactions to API Server

Author: OBorce

CHANGELOG.md

@@ -82,6 +82,17 @@ struct ApiServerInMemoryStorage {
     statistics:
         BTreeMap<CoinOrTokenStatistic, BTreeMap<CoinOrTokenId, BTreeMap<BlockHeight, Amount>>>,
     orders_table: BTreeMap<OrderId, BTreeMap<BlockHeight, Order>>,
+    mempool_transaction_table: BTreeMap<Id<Transaction>, TransactionInfo>,
+    mempool_utxo_table: BTreeMap<UtxoOutPoint, (Utxo, bool)>,
+    mempool_address_utxos: BTreeMap<String, BTreeSet<UtxoOutPoint>>,
+    mempool_address_balance_table: BTreeMap<String, BTreeMap<CoinOrTokenId, AmountWithDecimals>>,
+    mempool_locked_address_balance_table:
+        BTreeMap<String, BTreeMap<CoinOrTokenId, AmountWithDecimals>>,
+    mempool_address_transactions_table: BTreeMap<String, BTreeSet<Id<Transaction>>>,
+    mempool_token_transactions_table: BTreeMap<TokenId, BTreeSet<Id<Transaction>>>,
+    mempool_fungible_token_data: BTreeMap<TokenId, FungibleTokenData>,
+    mempool_nft_token_issuances: BTreeMap<TokenId, NftWithOwner>,
+    mempool_orders_table: BTreeMap<OrderId, Order>,
     genesis_block: Arc<WithId<Genesis>>,
     number_of_coin_decimals: u8,
     storage_version: u32,
@@ -109,6 +120,16 @@ impl ApiServerInMemoryStorage {
             nft_token_issuances: BTreeMap::new(),
             statistics: BTreeMap::new(),
             orders_table: BTreeMap::new(),
+            mempool_transaction_table: BTreeMap::new(),
+            mempool_utxo_table: BTreeMap::new(),
+            mempool_address_utxos: BTreeMap::new(),
+            mempool_address_balance_table: BTreeMap::new(),
+            mempool_locked_address_balance_table: BTreeMap::new(),
+            mempool_address_transactions_table: BTreeMap::new(),
+            mempool_token_transactions_table: BTreeMap::new(),
+            mempool_fungible_token_data: BTreeMap::new(),
+            mempool_nft_token_issuances: BTreeMap::new(),
+            mempool_orders_table: BTreeMap::new(),
             genesis_block: chain_config.genesis_block().clone(),
             number_of_coin_decimals: chain_config.coin_decimals(),
             storage_version: CURRENT_STORAGE_VERSION,
@@ -840,6 +861,127 @@ impl ApiServerInMemoryStorage {
         });
         Ok(())
     }
+
+    fn get_utxo_mempool_fallback(
+        &self,
+        outpoint: &UtxoOutPoint,
+    ) -> Result<Option<Utxo>, ApiServerStorageError> {
+        if let Some(res) = self.mempool_utxo_table.get(outpoint).map(|(utxo, _)| utxo.clone()) {
+            return Ok(Some(res));
+        }
+
+        self.get_utxo(outpoint.clone())
+    }
+
+    fn get_mempool_address_balance(
+        &self,
+        address: &str,
+        coin_or_token_id: CoinOrTokenId,
+    ) -> Result<Option<Amount>, ApiServerStorageError> {
+        let mempool_balance = self
+            .mempool_address_balance_table
+            .get(address)
+            .and_then(|by_coin| by_coin.get(&coin_or_token_id).map(|amount| amount.amount));
+
+        if mempool_balance.is_some() {
+            return Ok(mempool_balance);
+        }
+
+        self.get_address_balance(address, coin_or_token_id)
+    }
+
+    fn get_mempool_locked_address_balance(
+        &self,
+        address: &str,
+        coin_or_token_id: CoinOrTokenId,
+    ) -> Result<Option<Amount>, ApiServerStorageError> {
+        let mempool_balance = self
+            .mempool_locked_address_balance_table
+            .get(address)
+            .and_then(|by_coin| by_coin.get(&coin_or_token_id).map(|amount| amount.amount));
+
+        if mempool_balance.is_some() {
+            return Ok(mempool_balance);
+        }
+
+        self.get_address_locked_balance(address, coin_or_token_id)
+    }
+
+    fn get_mempool_transaction(
+        &self,
+        transaction_id: Id<Transaction>,
+    ) -> Result<Option<TransactionInfo>, ApiServerStorageError> {
+        Ok(self.mempool_transaction_table.get(&transaction_id).cloned())
+    }
+
+    fn get_mempool_transactions(
+        &self,
+        len: u32,
+        offset: u64,
+    ) -> Result<Vec<TransactionInfo>, ApiServerStorageError> {
+        Ok(self
+            .mempool_transaction_table
+            .values()
+            .skip(offset as usize)
+            .take(len as usize)
+            .cloned()
+            .collect())
+    }
+
+    fn get_mempool_address_transactions(
+        &self,
+        address: &str,
+    ) -> Result<Vec<Id<common::chain::Transaction>>, ApiServerStorageError> {
+        Ok(self
+            .mempool_address_transactions_table
+            .get(address)
+            .map(|txs| txs.iter().copied().collect())
+            .unwrap_or_default())
+    }
+
+    fn get_mempool_address_balances(
+        &self,
+        address: &str,
+    ) -> Result<BTreeMap<CoinOrTokenId, AmountWithDecimals>, ApiServerStorageError> {
+        Ok(self
+            .mempool_address_balance_table
+            .get(address)
+            .cloned()
+            .map(|balances| balances.into_iter().collect())
+            .unwrap_or_default())
+    }
+
+    fn get_mempool_address_all_utxos(
+        &self,
+        address: &str,
+    ) -> Result<Vec<(UtxoOutPoint, UtxoWithExtraInfo)>, ApiServerStorageError> {
+        let result = self
+            .mempool_address_utxos
+            .get(address)
+            .unwrap_or(&BTreeSet::new())
+            // TODO:
+            .union(self.address_locked_utxos.get(address).unwrap_or(&BTreeSet::new()))
+            .filter_map(|outpoint| {
+                if let Some(utxo) = self.get_utxo_mempool_fallback(outpoint).expect("no error") {
+                    (!utxo.spent())
+                        .then_some((outpoint.clone(), utxo.utxo_with_extra_info().clone()))
+                } else {
+                    Some((
+                        outpoint.clone(),
+                        self.locked_utxo_table
+                            .get(outpoint)
+                            .expect("must exit")
+                            .values()
+                            .last()
+                            .expect("not empty")
+                            .utxo_with_extra_info()
+                            .clone(),
+                    ))
+                }
+            })
+            .collect();
+        Ok(result)
+    }
 }
 
 impl ApiServerInMemoryStorage {
@@ -1292,4 +1434,154 @@ impl ApiServerInMemoryStorage {
 
         Ok(())
     }
+
+    fn set_mempool_transaction(
+        &mut self,
+        transaction_id: Id<Transaction>,
+        transaction: &TransactionInfo,
+    ) -> Result<(), ApiServerStorageError> {
+        self.mempool_transaction_table.insert(transaction_id, transaction.clone());
+        Ok(())
+    }
+
+    fn set_mempool_utxo(
+        &mut self,
+        outpoint: UtxoOutPoint,
+        utxo: Utxo,
+        spent: bool,
+        addresses: &[&str],
+    ) -> Result<(), ApiServerStorageError> {
+        self.mempool_utxo_table.insert(outpoint.clone(), (utxo, spent));
+        for address in addresses {
+            self.mempool_address_utxos
+                .entry((*address).into())
+                .or_default()
+                .insert(outpoint.clone());
+        }
+        Ok(())
+    }
+
+    fn set_mempool_address_balance(
+        &mut self,
+        address: &str,
+        coin_or_token_id: CoinOrTokenId,
+        amount: Amount,
+        decimals: u8,
+    ) -> Result<(), ApiServerStorageError> {
+        self.mempool_address_balance_table
+            .entry(address.to_string())
+            .or_default()
+            .insert(coin_or_token_id, AmountWithDecimals { amount, decimals });
+        Ok(())
+    }
+
+    fn set_mempool_locked_address_balance(
+        &mut self,
+        address: &str,
+        coin_or_token_id: CoinOrTokenId,
+        amount: Amount,
+        decimals: u8,
+    ) -> Result<(), ApiServerStorageError> {
+        self.mempool_locked_address_balance_table
+            .entry(address.to_string())
+            .or_default()
+            .insert(coin_or_token_id, AmountWithDecimals { amount, decimals });
+        Ok(())
+    }
+
+    fn set_mempool_address_transaction(
+        &mut self,
+        address: &str,
+        transaction_id: Id<Transaction>,
+    ) -> Result<(), ApiServerStorageError> {
+        self.mempool_address_transactions_table
+            .entry(address.to_string())
+            .or_default()
+            .insert(transaction_id);
+        Ok(())
+    }
+
+    fn set_mempool_token_transaction(
+        &mut self,
+        token_id: TokenId,
+        transaction_id: Id<Transaction>,
+    ) -> Result<(), ApiServerStorageError> {
+        self.mempool_token_transactions_table
+            .entry(token_id)
+            .or_default()
+            .insert(transaction_id);
+        Ok(())
+    }
+
+    fn set_mempool_fungible_token_issuance(
+        &mut self,
+        token_id: TokenId,
+        issuance: FungibleTokenData,
+    ) -> Result<(), ApiServerStorageError> {
+        self.mempool_fungible_token_data.insert(token_id, issuance);
+        Ok(())
+    }
+
+    fn set_mempool_nft_issuance(
+        &mut self,
+        token_id: TokenId,
+        issuance: NftIssuance,
+        owner: &Destination,
+    ) -> Result<(), ApiServerStorageError> {
+        self.mempool_nft_token_issuances.insert(
+            token_id,
+            NftWithOwner {
+                nft: issuance,
+                owner: Some(owner.clone()),
+            },
+        );
+        Ok(())
+    }
+
+    fn get_mempool_token_num_decimals(
+        &self,
+        token_id: TokenId,
+    ) -> Result<Option<u8>, ApiServerStorageError> {
+        let decimals = self
+            .mempool_fungible_token_data
+            .get(&token_id)
+            .map(|data| data.number_of_decimals)
+            .or_else(|| self.mempool_nft_token_issuances.get(&token_id).map(|_| 0));
+
+        if decimals.is_some() {
+            return Ok(decimals);
+        }
+
+        self.get_token_num_decimals(token_id)
+    }
+
+    fn get_mempool_order(&self, order_id: OrderId) -> Result<Option<Order>, ApiServerStorageError> {
+        let order_result = self.mempool_orders_table.get(&order_id).cloned();
+        if order_result.is_some() {
+            return Ok(order_result);
+        }
+
+        self.get_order(order_id)
+    }
+
+    fn set_mempool_order(
+        &mut self,
+        order_id: OrderId,
+        order: Order,
+    ) -> Result<(), ApiServerStorageError> {
+        self.mempool_orders_table.insert(order_id, order);
+        Ok(())
+    }
+
+    fn clear_mempool_data(&mut self) -> Result<(), ApiServerStorageError> {
+        self.mempool_transaction_table.clear();
+        self.mempool_utxo_table.clear();
+        self.mempool_address_utxos.clear();
+        self.mempool_address_balance_table.clear();
+        self.mempool_address_transactions_table.clear();
+        self.mempool_token_transactions_table.clear();
+        self.mempool_fungible_token_data.clear();
+        self.mempool_nft_token_issuances.clear();
+        Ok(())
+    }
 }

api-server/api-server-common/src/storage/impls/in_memory/mod.rs

@@ -317,4 +317,77 @@ impl ApiServerStorageRead for ApiServerInMemoryStorageTransactionalRo<'_> {
     ) -> Result<Vec<(OrderId, Order)>, ApiServerStorageError> {
         self.transaction.get_orders_for_trading_pair(pair, len, offset)
     }
+
+    async fn get_utxo_mempool_fallback(
+        &self,
+        outpoint: &UtxoOutPoint,
+    ) -> Result<Option<Utxo>, ApiServerStorageError> {
+        self.transaction.get_utxo_mempool_fallback(outpoint)
+    }
+
+    async fn get_mempool_address_balance(
+        &self,
+        address: &str,
+        coin_or_token_id: CoinOrTokenId,
+    ) -> Result<Option<Amount>, ApiServerStorageError> {
+        self.transaction.get_mempool_address_balance(address, coin_or_token_id)
+    }
+
+    async fn get_mempool_locked_address_balance(
+        &self,
+        address: &str,
+        coin_or_token_id: CoinOrTokenId,
+    ) -> Result<Option<Amount>, ApiServerStorageError> {
+        self.transaction.get_mempool_locked_address_balance(address, coin_or_token_id)
+    }
+
+    async fn get_mempool_transaction(
+        &self,
+        transaction_id: Id<Transaction>,
+    ) -> Result<Option<TransactionInfo>, ApiServerStorageError> {
+        self.transaction.get_mempool_transaction(transaction_id)
+    }
+
+    async fn get_mempool_transactions(
+        &self,
+        len: u32,
+        offset: u64,
+    ) -> Result<Vec<TransactionInfo>, ApiServerStorageError> {
+        self.transaction.get_mempool_transactions(len, offset)
+    }
+
+    async fn get_mempool_address_transactions(
+        &self,
+        address: &str,
+    ) -> Result<Vec<Id<common::chain::Transaction>>, ApiServerStorageError> {
+        self.transaction.get_mempool_address_transactions(address)
+    }
+
+    async fn get_mempool_address_balances(
+        &self,
+        address: &str,
+    ) -> Result<BTreeMap<CoinOrTokenId, AmountWithDecimals>, ApiServerStorageError> {
+        self.transaction.get_mempool_address_balances(address)
+    }
+
+    async fn get_mempool_address_all_utxos(
+        &self,
+        address: &str,
+    ) -> Result<Vec<(UtxoOutPoint, UtxoWithExtraInfo)>, ApiServerStorageError> {
+        self.transaction.get_mempool_address_all_utxos(address)
+    }
+
+    async fn get_mempool_token_num_decimals(
+        &self,
+        token_id: TokenId,
+    ) -> Result<Option<u8>, ApiServerStorageError> {
+        self.transaction.get_mempool_token_num_decimals(token_id)
+    }
+
+    async fn get_mempool_order(
+        &self,
+        order_id: OrderId,
+    ) -> Result<Option<Order>, ApiServerStorageError> {
+        self.transaction.get_mempool_order(order_id)
+    }
 }