Refactor token tests in chainstate to check all available token data. Add separate test for get_tokens_info_for_rpc

Author: ImplOfAnImpl

Cargo.lock

@@ -361,6 +361,8 @@ impl<'a, S: BlockchainStorageRead, V: TransactionVerificationStrategy> Chainstat
         self.last_common_ancestor(block_index, &best_block_index)
     }
 
+    // Note: this function will return Some for NFTs only, because the data is only written
+    // for NFTs. This is decided by `token_issuance_cache::has_tokens_issuance_to_cache`.
     #[log_error]
     pub fn get_token_aux_data(
         &self,
@@ -369,8 +371,9 @@ impl<'a, S: BlockchainStorageRead, V: TransactionVerificationStrategy> Chainstat
         self.db_tx.get_token_aux_data(token_id).map_err(PropertyQueryError::from)
     }
 
+    // Note: same as get_token_aux_data, this only works for NFTs, for the same reason.
     #[log_error]
-    pub fn get_token_id(
+    pub fn get_token_id_from_issuance_tx(
         &self,
         tx_id: &Id<Transaction>,
     ) -> Result<Option<TokenId>, PropertyQueryError> {

chainstate/src/detail/chainstateref/mod.rs

@@ -391,7 +391,7 @@ impl<'a, S: BlockchainStorageRead, V: TransactionVerificationStrategy> Chainstat
         &self,
         tx_id: &Id<Transaction>,
     ) -> Result<Option<TokenId>, PropertyQueryError> {
-        self.chainstate_ref.get_token_id(tx_id)
+        self.chainstate_ref.get_token_id_from_issuance_tx(tx_id)
     }
 
     pub fn get_mainchain_blocks_list(&self) -> Result<Vec<Id<Block>>, PropertyQueryError> {

chainstate/src/detail/query.rs

@@ -217,14 +217,17 @@ pub trait ChainstateInterface: Send + Sync {
         token_ids: &BTreeSet<TokenId>,
     ) -> Result<Vec<RPCTokenInfo>, ChainstateError>;
 
+    /// Return token's auxiliary data; available for NFTs only.
     fn get_token_aux_data(
         &self,
         token_id: TokenId,
     ) -> Result<Option<TokenAuxiliaryData>, ChainstateError>;
+    /// Obtain token id given the id of the issuing tx; available for NFTs only.
     fn get_token_id_from_issuance_tx(
         &self,
         tx_id: &Id<Transaction>,
     ) -> Result<Option<TokenId>, ChainstateError>;
+    /// Obtain token data given its id; available for fungible tokens only.
     fn get_token_data(
         &self,
         id: &TokenId,

chainstate/src/interface/chainstate_interface.rs

@@ -64,7 +64,7 @@ pub fn issue_and_mint_random_token_from_best_block(
         TokenIssuance::V1(issuance)
     };
 
-    let (token_id, _, utxo_with_change) =
+    let (token_id, _, _, utxo_with_change) =
         issue_token_from_block(rng, tf, best_block_id, utxo_to_pay_fee, issuance);
 
     let best_block_id = tf.best_block_id();
@@ -91,7 +91,12 @@ pub fn issue_token_from_block(
     parent_block_id: Id<GenBlock>,
     utxo_to_pay_fee: UtxoOutPoint,
     issuance: TokenIssuance,
-) -> (TokenId, Id<Block>, UtxoOutPoint) {
+) -> (
+    TokenId,
+    /*issuance_block_id*/ Id<Block>,
+    /*issuance_tx*/ Transaction,
+    /*change_outpoint*/ UtxoOutPoint,
+) {
     let token_issuance_fee = tf.chainstate.get_chain_config().fungible_token_issuance_fee();
 
     let fee_utxo_coins =
@@ -118,13 +123,64 @@ pub fn issue_token_from_block(
     let tx_id = tx.transaction().get_id();
     let block = tf
         .make_block_builder()
-        .add_transaction(tx)
+        .add_transaction(tx.clone())
         .with_parent(parent_block_id)
         .build(rng);
     let block_id = block.get_id();
     tf.process_block(block, BlockSource::Local).unwrap();
 
-    (token_id, block_id, UtxoOutPoint::new(tx_id.into(), 0))
+    (
+        token_id,
+        block_id,
+        tx.take_transaction(),
+        UtxoOutPoint::new(tx_id.into(), 0),
+    )
+}
+
+pub fn make_token_issuance(
+    rng: &mut impl Rng,
+    supply: TokenTotalSupply,
+    freezable: IsTokenFreezable,
+) -> TokenIssuance {
+    TokenIssuance::V1(TokenIssuanceV1 {
+        token_ticker: random_ascii_alphanumeric_string(rng, 1..5).as_bytes().to_vec(),
+        number_of_decimals: rng.gen_range(1..18),
+        metadata_uri: random_ascii_alphanumeric_string(rng, 1..1024).as_bytes().to_vec(),
+        total_supply: supply,
+        authority: Destination::AnyoneCanSpend,
+        is_freezable: freezable,
+    })
+}
+
+pub fn issue_token_from_genesis(
+    rng: &mut (impl Rng + CryptoRng),
+    tf: &mut TestFramework,
+    supply: TokenTotalSupply,
+    freezable: IsTokenFreezable,
+) -> (
+    TokenId,
+    /*issuance_block_id*/ Id<Block>,
+    /*issuance_tx*/ Transaction,
+    TokenIssuance,
+    /*change_outpoint*/ UtxoOutPoint,
+) {
+    let utxo_input_outpoint = UtxoOutPoint::new(tf.best_block_id().into(), 0);
+    let issuance = make_token_issuance(rng, supply, freezable);
+    let (token_id, issuance_block_id, issuance_tx, change_outpoint) = issue_token_from_block(
+        rng,
+        tf,
+        tf.genesis().get_id().into(),
+        utxo_input_outpoint,
+        issuance.clone(),
+    );
+
+    (
+        token_id,
+        issuance_block_id,
+        issuance_tx,
+        issuance,
+        change_outpoint,
+    )
 }
 
 pub fn mint_tokens_in_block(

chainstate/test-framework/src/helpers.rs

@@ -37,6 +37,7 @@ tokio = { workspace = true, features = ["rt", "time"] }
 
 criterion.workspace = true
 expect-test.workspace = true
+rand.workspace = true
 rstest.workspace = true
 
 [[bench]]