Add test for token upgrade

Author: azarovh

chainstate/test-suite/src/tests/fungible_tokens_v1.rs

@@ -6296,4 +6296,153 @@ fn only_authority_can_change_metadata_uri(#[case] seed: Seed) {
     });
 }
 
-// FIXME: add tests
+#[rstest]
+#[trace]
+#[case(Seed::from_entropy())]
+fn test_make_token_id_activation(#[case] seed: Seed) {
+    use common::chain::make_token_id;
+
+    utils::concurrency::model(move || {
+        let mut rng = test_utils::random::make_seedable_rng(seed);
+        // activate feature at height 3
+        let mut tf = TestFramework::builder(&mut rng)
+            .with_chain_config(
+                common::chain::config::Builder::test_chain()
+                    .chainstate_upgrades(
+                        common::chain::NetUpgrades::initialize(vec![
+                            (
+                                BlockHeight::zero(),
+                                ChainstateUpgradeBuilder::latest()
+                                    .token_id_generation_version(
+                                        common::chain::TokenIdGenerationVersion::V0,
+                                    )
+                                    .build(),
+                            ),
+                            (
+                                BlockHeight::new(3),
+                                ChainstateUpgradeBuilder::latest()
+                                    .token_id_generation_version(
+                                        common::chain::TokenIdGenerationVersion::V1,
+                                    )
+                                    .build(),
+                            ),
+                        ])
+                        .unwrap(),
+                    )
+                    .genesis_unittest(Destination::AnyoneCanSpend)
+                    .build(),
+            )
+            .build();
+
+        // Create a token just so that there is an account to use in inputs
+        let (token_id_0, _, utxo_with_change) = issue_token_from_genesis(
+            &mut rng,
+            &mut tf,
+            TokenTotalSupply::Lockable,
+            IsTokenFreezable::Yes,
+        );
+
+        // Create a token from account input
+        let issuance = make_issuance(&mut rng, TokenTotalSupply::Unlimited, IsTokenFreezable::No);
+        let token_issuance_fee = tf.chainstate.get_chain_config().fungible_token_issuance_fee();
+        let token_change_authority_fee =
+            tf.chainstate.get_chain_config().token_change_authority_fee(BlockHeight::zero());
+
+        let tx1 = TransactionBuilder::new()
+            .add_input(
+                TxInput::AccountCommand(
+                    AccountNonce::new(0),
+                    AccountCommand::LockTokenSupply(token_id_0),
+                ),
+                InputWitness::NoSignature(None),
+            )
+            .add_input(
+                utxo_with_change.clone().into(),
+                InputWitness::NoSignature(None),
+            )
+            .add_output(TxOutput::Transfer(
+                OutputValue::Coin((token_issuance_fee + token_change_authority_fee).unwrap()),
+                Destination::AnyoneCanSpend,
+            ))
+            .add_output(TxOutput::IssueFungibleToken(Box::new(issuance.clone())))
+            .build();
+
+        let issue_token_1_tx_id = tx1.transaction().get_id();
+        let token_id_1 = make_token_id(
+            tf.chain_config(),
+            tf.best_block_index().block_height().next_height(),
+            tx1.transaction().inputs(),
+        )
+        .unwrap();
+
+        let _ = tf
+            .make_block_builder()
+            .add_transaction(tx1)
+            .build_and_process(&mut rng)
+            .unwrap();
+
+        let token_1_data = TokensAccountingStorageRead::get_token_data(
+            &tf.storage.transaction_ro().unwrap(),
+            &token_id_1,
+        )
+        .unwrap();
+        assert!(token_1_data.is_some());
+        assert_ne!(token_id_1, TokenId::from_utxo(&utxo_with_change));
+
+        // Check that at height 3 token is issued not from the first input but from the first utxo input
+        let tx2 = TransactionBuilder::new()
+            .add_input(
+                TxInput::AccountCommand(
+                    AccountNonce::new(1),
+                    AccountCommand::ChangeTokenAuthority(token_id_0, Destination::AnyoneCanSpend),
+                ),
+                InputWitness::NoSignature(None),
+            )
+            .add_input(
+                TxInput::from_utxo(issue_token_1_tx_id.clone().into(), 0),
+                InputWitness::NoSignature(None),
+            )
+            .add_output(TxOutput::IssueFungibleToken(Box::new(issuance.clone())))
+            .build();
+
+        let token_id_2 = make_token_id(
+            tf.chain_config(),
+            tf.best_block_index().block_height().next_height(),
+            tx2.transaction().inputs(),
+        )
+        .unwrap();
+        assert_eq!(
+            token_id_2,
+            TokenId::from_utxo(&UtxoOutPoint::new(issue_token_1_tx_id.into(), 0))
+        );
+
+        // also make sure token was not created from account input
+        let invalid_token_id_from_account_input = make_token_id(
+            tf.chain_config(),
+            BlockHeight::zero(),
+            tx2.transaction().inputs(),
+        )
+        .unwrap();
+        assert_ne!(token_id_2, invalid_token_id_from_account_input);
+
+        let _ = tf
+            .make_block_builder()
+            .add_transaction(tx2)
+            .build_and_process(&mut rng)
+            .unwrap();
+
+        let token_2_data = TokensAccountingStorageRead::get_token_data(
+            &tf.storage.transaction_ro().unwrap(),
+            &token_id_2,
+        )
+        .unwrap();
+        assert!(token_2_data.is_some());
+
+        let token_2_data_invalid = TokensAccountingStorageRead::get_token_data(
+            &tf.storage.transaction_ro().unwrap(),
+            &invalid_token_id_from_account_input,
+        )
+        .unwrap();
+        assert!(token_2_data_invalid.is_none());
+    });
+}

chainstate/test-suite/src/tests/homomorphism.rs

@@ -183,7 +183,7 @@ fn tokens_homomorphism(#[case] seed: Seed) {
 
         let tx_1 = TransactionBuilder::new()
             .add_input(
-                TxInput::from_utxo(genesis_id.clone().into(), 0),
+                TxInput::from_utxo(genesis_id.into(), 0),
                 empty_witness(&mut rng),
             )
             .add_output(TxOutput::IssueFungibleToken(Box::new(TokenIssuance::V1(
@@ -200,7 +200,7 @@ fn tokens_homomorphism(#[case] seed: Seed) {
                 Destination::AnyoneCanSpend,
             ))
             .build();
-        let token_id = TokenId::from_utxo(&UtxoOutPoint::new(genesis_id.clone().into(), 0));
+        let token_id = TokenId::from_utxo(&UtxoOutPoint::new(genesis_id.into(), 0));
 
         let tx_2 = TransactionBuilder::new()
             .add_input(

chainstate/test-suite/src/tests/nft_issuance.rs

@@ -2023,5 +2023,3 @@ fn issue_nft_and_fungible_token_same_tx(#[case] seed: Seed) {
         ));
     })
 }
-
-// FIXME: add tests

common/src/chain/upgrades/chainstate_upgrade.rs

@@ -81,6 +81,8 @@ pub enum OrdersVersion {
     V1,
 }
 
+// TODO: after it's activated and reorg depth passes check mainnet/testnet and in case V0 doesn't conflict with
+// V1 this upgrade can be removed from the codebase.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Ord, PartialOrd)]
 pub enum TokenIdGenerationVersion {
     V0,

common/test-helpers/src/chainstate_upgrade_builder.rs

@@ -85,4 +85,5 @@ impl ChainstateUpgradeBuilder {
     builder_method!(orders_activated: OrdersActivated);
     builder_method!(orders_version: OrdersVersion);
     builder_method!(staker_destination_update_forbidden: StakerDestinationUpdateForbidden);
+    builder_method!(token_id_generation_version: TokenIdGenerationVersion);
 }