Only ascii alphanumeric in tokens after v1

Author: azarovh

chainstate/src/detail/block_checking.rs

@@ -16,6 +16,7 @@
 use super::Chainstate;
 use crate::{BlockError, TransactionVerificationStrategy};
 use chainstate_storage::BlockchainStorage;
+use chainstate_types::PropertyQueryError;
 use common::{
     chain::{block::signed_block_header::SignedBlockHeader, Block},
     primitives::id::WithId,
@@ -36,7 +37,17 @@ impl<'a, S: BlockchainStorage, V: TransactionVerificationStrategy> BlockChecker<
         block: WithId<Block>,
     ) -> Result<WithId<Block>, BlockError> {
         let chainstate_ref = self.chainstate.make_db_tx_ro().map_err(BlockError::from)?;
-        chainstate_ref.check_block(&block).log_err()?;
+        let prev_block_id = block.prev_block_id();
+        let parent_height = chainstate_ref
+            .get_gen_block_index(&prev_block_id)
+            .map_err(|e| BlockError::BlockIndexQueryError(prev_block_id, e))?
+            .ok_or(BlockError::BlockIndexQueryError(
+                prev_block_id,
+                PropertyQueryError::BlockIndexNotFound(prev_block_id),
+            ))?
+            .block_height();
+
+        chainstate_ref.check_block(&block, parent_height.next_height()).log_err()?;
         Ok(block)
     }
 

chainstate/src/detail/chainstateref/mod.rs

@@ -740,7 +740,11 @@ impl<'a, S: BlockchainStorageRead, V: TransactionVerificationStrategy> Chainstat
         Ok(())
     }
 
-    fn check_tokens_txs(&self, block: &Block) -> Result<(), CheckBlockTransactionsError> {
+    fn check_tokens_txs(
+        &self,
+        block: &Block,
+        block_height: BlockHeight,
+    ) -> Result<(), CheckBlockTransactionsError> {
         for tx in block.transactions() {
             // We can't issue multiple tokens in a single tx
             let issuance_count = get_tokens_issuance_count(tx.outputs());
@@ -767,29 +771,32 @@ impl<'a, S: BlockchainStorageRead, V: TransactionVerificationStrategy> Chainstat
                                 token_data,
                                 tx.transaction(),
                                 block.get_id(),
+                                block_height,
                             )?;
                         }
                         Ok(())
                     }
                     TxOutput::TokensOp(token_output) => match token_output {
                         TokenOutput::IssueFungibleToken(issuance) => {
-                            check_tokens_issuance(self.chain_config, issuance).map_err(|e| {
-                                TokensError::IssueError(
-                                    e,
-                                    tx.transaction().get_id(),
-                                    block.get_id(),
-                                )
-                            })
-                        }
-                        TokenOutput::IssueNft(_, issuance, _) => match issuance.as_ref() {
-                            NftIssuance::V0(data) => {
-                                check_nft_issuance_data(self.chain_config, data).map_err(|e| {
+                            check_tokens_issuance(self.chain_config, block_height, issuance)
+                                .map_err(|e| {
                                     TokensError::IssueError(
                                         e,
                                         tx.transaction().get_id(),
                                         block.get_id(),
                                     )
                                 })
+                        }
+                        TokenOutput::IssueNft(_, issuance, _) => match issuance.as_ref() {
+                            NftIssuance::V0(data) => {
+                                check_nft_issuance_data(self.chain_config, block_height, data)
+                                    .map_err(|e| {
+                                        TokensError::IssueError(
+                                            e,
+                                            tx.transaction().get_id(),
+                                            block.get_id(),
+                                        )
+                                    })
                             }
                         },
                     },
@@ -826,11 +833,15 @@ impl<'a, S: BlockchainStorageRead, V: TransactionVerificationStrategy> Chainstat
         Ok(())
     }
 
-    fn check_transactions(&self, block: &Block) -> Result<(), CheckBlockTransactionsError> {
+    fn check_transactions(
+        &self,
+        block: &Block,
+        block_height: BlockHeight,
+    ) -> Result<(), CheckBlockTransactionsError> {
         // Note: duplicate txs are detected through duplicate inputs
         self.check_witness_count(block).log_err()?;
         self.check_duplicate_inputs(block).log_err()?;
-        self.check_tokens_txs(block).log_err()?;
+        self.check_tokens_txs(block, block_height).log_err()?;
         self.check_no_signature_size(block).log_err()?;
         Ok(())
     }
@@ -842,7 +853,11 @@ impl<'a, S: BlockchainStorageRead, V: TransactionVerificationStrategy> Chainstat
         self.db_tx.get_block(*block_index.block_id()).log_err()
     }
 
-    pub fn check_block(&self, block: &WithId<Block>) -> Result<(), CheckBlockError> {
+    pub fn check_block(
+        &self,
+        block: &WithId<Block>,
+        block_height: BlockHeight,
+    ) -> Result<(), CheckBlockError> {
         self.check_block_header(block.header()).log_err()?;
 
         self.check_block_size(block)
@@ -874,7 +889,7 @@ impl<'a, S: BlockchainStorageRead, V: TransactionVerificationStrategy> Chainstat
             );
         }
 
-        self.check_transactions(block)
+        self.check_transactions(block, block_height)
             .map_err(CheckBlockError::CheckTransactionFailed)
             .log_err()?;
 
@@ -1164,7 +1179,7 @@ impl<'a, S: BlockchainStorageWrite, V: TransactionVerificationStrategy> Chainsta
             );
 
             if new_tip_status.last_valid_stage() < BlockValidationStage::CheckBlockOk {
-                self.check_block(new_tip)?;
+                self.check_block(new_tip, new_tip_block_index.block_height())?;
                 new_tip_status.advance_validation_stage_to(BlockValidationStage::CheckBlockOk);
             }
 

chainstate/src/detail/mod.rs

@@ -330,7 +330,7 @@ impl<S: BlockchainStorage, V: TransactionVerificationStrategy> Chainstate<S, V>
     ) -> Result<bool, BlockIntegrationError> {
         let mut block_status = BlockStatus::new();
 
-        let result = chainstate_ref.check_block(block);
+        let result = chainstate_ref.check_block(block, block_index.block_height());
         if result.is_err() {
             // TODO: "technical" errors (e.g. a DB error) should not lead to permanent
             // block invalidation. The same applies to the other unconditional

chainstate/src/detail/tokens/check_utils.rs

@@ -13,11 +13,21 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use common::chain::ChainConfig;
+use common::{
+    chain::{tokens::TokenIssuanceVersion, ChainConfig},
+    primitives::BlockHeight,
+};
 use tx_verifier::error::TokenIssuanceError;
 use utils::ensure;
 
 fn check_is_text_alphanumeric(str: &[u8]) -> bool {
+    match String::from_utf8(str.to_vec()) {
+        Ok(text) => text.chars().all(char::is_alphanumeric),
+        Err(_) => false,
+    }
+}
+
+fn check_is_text_ascii_alphanumeric(str: &[u8]) -> bool {
     match String::from_utf8(str.to_vec()) {
         Ok(text) => text.chars().all(|c| c.is_ascii_alphanumeric()),
         Err(_) => false,
@@ -53,6 +63,7 @@ pub fn check_media_hash(chain_config: &ChainConfig, hash: &[u8]) -> Result<(), T
 
 pub fn check_token_ticker(
     chain_config: &ChainConfig,
+    current_height: BlockHeight,
     ticker: &[u8],
 ) -> Result<(), TokenIssuanceError> {
     // Check length
@@ -62,30 +73,68 @@ pub fn check_token_ticker(
     );
 
     // Check is ticker has alphanumeric chars
-    ensure!(
-        check_is_text_alphanumeric(ticker),
-        TokenIssuanceError::IssueErrorTickerHasNoneAlphaNumericChar
-    );
+    let tokens_version = chain_config
+        .chainstate_upgrades()
+        .version_at_height(current_height)
+        .1
+        .token_issuance_version();
+
+    match tokens_version {
+        TokenIssuanceVersion::V0 => {
+            ensure!(
+                check_is_text_alphanumeric(ticker),
+                TokenIssuanceError::IssueErrorTickerHasNoneAlphaNumericChar
+            );
+        }
+        TokenIssuanceVersion::V1 => {
+            ensure!(
+                check_is_text_ascii_alphanumeric(ticker),
+                TokenIssuanceError::IssueErrorTickerHasNoneAlphaNumericChar
+            );
+        }
+    }
+
     Ok(())
 }
 
-pub fn check_nft_name(chain_config: &ChainConfig, name: &[u8]) -> Result<(), TokenIssuanceError> {
+pub fn check_nft_name(
+    chain_config: &ChainConfig,
+    current_height: BlockHeight,
+    name: &[u8],
+) -> Result<(), TokenIssuanceError> {
     // Check length
     ensure!(
         name.len() <= chain_config.token_max_name_len() && !name.is_empty(),
         TokenIssuanceError::IssueErrorInvalidNameLength
     );
 
     // Check is name has alphanumeric chars
-    ensure!(
-        check_is_text_alphanumeric(name),
-        TokenIssuanceError::IssueErrorNameHasNoneAlphaNumericChar
-    );
+    let tokens_version = chain_config
+        .chainstate_upgrades()
+        .version_at_height(current_height)
+        .1
+        .token_issuance_version();
+
+    match tokens_version {
+        TokenIssuanceVersion::V0 => {
+            ensure!(
+                check_is_text_alphanumeric(name),
+                TokenIssuanceError::IssueErrorNameHasNoneAlphaNumericChar
+            );
+        }
+        TokenIssuanceVersion::V1 => {
+            ensure!(
+                check_is_text_ascii_alphanumeric(name),
+                TokenIssuanceError::IssueErrorNameHasNoneAlphaNumericChar
+            );
+        }
+    }
     Ok(())
 }
 
 pub fn check_nft_description(
     chain_config: &ChainConfig,
+    current_height: BlockHeight,
     description: &[u8],
 ) -> Result<(), TokenIssuanceError> {
     // Check length
@@ -95,9 +144,25 @@ pub fn check_nft_description(
     );
 
     // Check is description has alphanumeric chars
-    ensure!(
-        check_is_text_alphanumeric(description),
-        TokenIssuanceError::IssueErrorDescriptionHasNoneAlphaNumericChar
-    );
+    let tokens_version = chain_config
+        .chainstate_upgrades()
+        .version_at_height(current_height)
+        .1
+        .token_issuance_version();
+
+    match tokens_version {
+        TokenIssuanceVersion::V0 => {
+            ensure!(
+                check_is_text_alphanumeric(description),
+                TokenIssuanceError::IssueErrorDescriptionHasNoneAlphaNumericChar
+            );
+        }
+        TokenIssuanceVersion::V1 => {
+            ensure!(
+                check_is_text_ascii_alphanumeric(description),
+                TokenIssuanceError::IssueErrorDescriptionHasNoneAlphaNumericChar
+            );
+        }
+    }
     Ok(())
 }

chainstate/src/detail/tokens/mod.rs

@@ -21,7 +21,7 @@ use common::{
         tokens::{NftIssuanceV0, TokenData, TokenIssuance, TokenIssuanceV0},
         Block, ChainConfig, Transaction,
     },
-    primitives::{Amount, Id, Idable},
+    primitives::{Amount, BlockHeight, Id, Idable},
 };
 use serialization::{DecodeAll, Encode};
 use tx_verifier::error::TokenIssuanceError;
@@ -33,11 +33,12 @@ use check_utils::{check_nft_description, check_nft_name, check_token_ticker, is_
 
 pub fn check_nft_issuance_data(
     chain_config: &ChainConfig,
+    current_height: BlockHeight,
     issuance: &NftIssuanceV0,
 ) -> Result<(), TokenIssuanceError> {
-    check_token_ticker(chain_config, &issuance.metadata.ticker)?;
-    check_nft_name(chain_config, &issuance.metadata.name)?;
-    check_nft_description(chain_config, &issuance.metadata.description)?;
+    check_token_ticker(chain_config, current_height, &issuance.metadata.ticker)?;
+    check_nft_name(chain_config, current_height, &issuance.metadata.name)?;
+    check_nft_description(chain_config, current_height, &issuance.metadata.description)?;
 
     let icon_uri = Vec::<u8>::decode_all(&mut issuance.metadata.icon_uri.encode().as_slice())
         .map_err(|_| TokenIssuanceError::IssueErrorIncorrectIconURI)?;
@@ -84,10 +85,11 @@ pub fn check_nft_issuance_data(
 
 pub fn check_tokens_issuance_data_v0(
     chain_config: &ChainConfig,
+    current_height: BlockHeight,
     issuance_data: &TokenIssuanceV0,
 ) -> Result<(), TokenIssuanceError> {
     // Check token ticker
-    check_token_ticker(chain_config, &issuance_data.token_ticker)?;
+    check_token_ticker(chain_config, current_height, &issuance_data.token_ticker)?;
 
     // Check amount
     ensure!(
@@ -116,12 +118,13 @@ pub fn check_tokens_issuance_data_v0(
 
 pub fn check_tokens_issuance(
     chain_config: &ChainConfig,
+    current_height: BlockHeight,
     issuance: &TokenIssuance,
 ) -> Result<(), TokenIssuanceError> {
     match issuance {
         TokenIssuance::V1(issuance_data) => {
             // Check token ticker
-            check_token_ticker(chain_config, &issuance_data.token_ticker)?;
+            check_token_ticker(chain_config, current_height, &issuance_data.token_ticker)?;
 
             // Check decimals
             ensure!(
@@ -150,6 +153,7 @@ pub fn check_tokens_data(
     token_data: &TokenData,
     tx: &Transaction,
     source_block_id: Id<Block>,
+    source_block_height: BlockHeight,
 ) -> Result<(), TokensError> {
     match token_data {
         TokenData::TokenTransfer(transfer) => {
@@ -159,9 +163,13 @@ pub fn check_tokens_data(
             );
             Ok(())
         }
-        TokenData::TokenIssuance(issuance) => check_tokens_issuance_data_v0(chain_config, issuance)
-            .map_err(|err| TokensError::IssueError(err, tx.get_id(), source_block_id)),
-        TokenData::NftIssuance(issuance) => check_nft_issuance_data(chain_config, issuance)
-            .map_err(|err| TokensError::IssueError(err, tx.get_id(), source_block_id)),
+        TokenData::TokenIssuance(issuance) => {
+            check_tokens_issuance_data_v0(chain_config, source_block_height, issuance)
+                .map_err(|err| TokensError::IssueError(err, tx.get_id(), source_block_id))
+        }
+        TokenData::NftIssuance(issuance) => {
+            check_nft_issuance_data(chain_config, source_block_height, issuance)
+                .map_err(|err| TokensError::IssueError(err, tx.get_id(), source_block_id))
+        }
     }
 }