Add OutputValue::TokenV1

Author: azarovh

chainstate/src/detail/chainstateref/mod.rs

@@ -739,6 +739,7 @@ impl<'a, S: BlockchainStorageRead, V: TransactionVerificationStrategy> Chainstat
     }
 
     fn check_tokens_txs(&self, block: &Block) -> Result<(), CheckBlockTransactionsError> {
+        // FIXME: check tokens versions
         for tx in block.transactions() {
             // We can't issue multiple tokens in a single tx
             let issuance_count = get_tokens_issuance_count(tx.outputs());

chainstate/test-framework/src/utils.rs

@@ -109,6 +109,7 @@ pub fn create_utxo_data(
                 new_token_transfer_output(chainstate, &outsrc, Amount::from_atoms(1))
             }
         },
+        OutputValue::TokenV1(_) => todo!(),
     };
 
     Some((
@@ -236,6 +237,7 @@ pub fn create_multiple_utxo_data(
                 }
             }
         },
+        OutputValue::TokenV1(_) => todo!(),
     };
 
     Some((

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

@@ -791,8 +791,6 @@ fn token_issuance_with_insufficient_fee(#[case] seed: Seed) {
     })
 }
 
-// FIXME: token_reissuance_with_insufficient_fee
-
 #[rstest]
 #[trace]
 #[case(Seed::from_entropy())]

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

@@ -245,3 +245,6 @@ fn token_issue_test(#[case] seed: Seed) {
         // FIXME: check that token account was created
     });
 }
+
+// FIXME: more tests
+// FIXME: token_reissuance_with_insufficient_fee

chainstate/tx-verifier/src/transaction_verifier/input_output_policy/constraints_accumulator.rs

@@ -162,19 +162,13 @@ impl ConstrainedValueAccumulator {
                             IOPolicyError::AttemptToPrintMoneyOrViolateTimelockConstraints,
                         )?;
                     }
-                    OutputValue::Token(token_data) => match token_data.as_ref() {
-                        TokenData::TokenTransfer(data) => {
-                            if let Some(constrained_amount) =
-                                self.burn_constrained.get_mut(&data.token_id)
-                            {
-                                *constrained_amount = (*constrained_amount - data.amount)
-                                    .ok_or(IOPolicyError::AmountOverflow)?;
-                            }
-                        }
-                        TokenData::TokenIssuance(_) | TokenData::NftIssuance(_) => {
-                            todo!("this has to handle TokenV1??")
+                    OutputValue::Token(_) => { /* do nothing */ }
+                    OutputValue::TokenV1((id, value)) => {
+                        if let Some(constrained_amount) = self.burn_constrained.get_mut(id) {
+                            *constrained_amount = (*constrained_amount - *value)
+                                .ok_or(IOPolicyError::AmountOverflow)?;
                         }
-                    },
+                    }
                 },
                 TxOutput::DelegateStaking(coins, _) => {
                     self.unconstrained_value = (self.unconstrained_value - *coins)

chainstate/tx-verifier/src/transaction_verifier/transferred_amount_check.rs

@@ -242,6 +242,7 @@ fn get_output_token_id_and_amount(
                 None => None,
             },
         },
+        OutputValue::TokenV1((id, amount)) => Some((CoinOrTokenId::TokenId(*id), *amount)),
     })
 }
 
@@ -270,6 +271,7 @@ where
                     TokensError::TokenIdCantBeCalculated,
                 )),
         },
+        OutputValue::TokenV1((id, amount)) => Ok((CoinOrTokenId::TokenId(*id), *amount)),
     }
 }
 

common/src/chain/tokens/tokens_utils.rs

@@ -53,7 +53,7 @@ pub fn get_tokens_issuance_v0_count(outputs: &[TxOutput]) -> usize {
                         TokenData::TokenIssuance(_) | TokenData::NftIssuance(_) => true,
                         TokenData::TokenTransfer(_) => false,
                     },
-                    OutputValue::Coin(_) => false,
+                    OutputValue::Coin(_) | OutputValue::TokenV1(_) => false,
                 }
             }
             TxOutput::CreateStakePool(_, _)
@@ -88,7 +88,7 @@ pub fn is_token_or_nft_issuance(output: &TxOutput) -> bool {
                     TokenData::TokenIssuance(_) | TokenData::NftIssuance(_) => true,
                     TokenData::TokenTransfer(_) => false,
                 },
-                OutputValue::Coin(_) => false,
+                OutputValue::Coin(_) | OutputValue::TokenV1(_) => false,
             }
         }
         TxOutput::TokenIssuance(_) => true,

common/src/chain/transaction/output/mod.rs

@@ -92,6 +92,7 @@ pub enum TxOutput {
     DelegateStaking(Amount, DelegationId),
     #[codec(index = 7)]
     TokenIssuance(Box<TokenIssuanceVersioned>),
+    // FIXME: add NftIssuance at once?
 }
 
 impl TxOutput {

common/src/chain/transaction/output/output_value.rs

@@ -16,28 +16,28 @@
 use serialization::{Decode, Encode};
 
 use crate::{
-    chain::tokens::{NftIssuance, TokenData, TokenIssuance, TokenTransfer},
+    chain::tokens::{NftIssuance, TokenData, TokenId, TokenIssuance, TokenTransfer},
     primitives::Amount,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq, Encode, Decode, serde::Serialize)]
 pub enum OutputValue {
     Coin(Amount),
-    Token(Box<TokenData>),
-    // FIXME: add TokenV1 with just amount
+    Token(Box<TokenData>), // FIXME: add check that this type is not used after upgrade
+    TokenV1((TokenId, Amount)),
 }
 
 impl OutputValue {
     pub fn coin_amount(&self) -> Option<Amount> {
         match self {
             OutputValue::Coin(v) => Some(*v),
-            OutputValue::Token(_) => None,
+            OutputValue::Token(_) | OutputValue::TokenV1(_) => None,
         }
     }
 
     pub fn token_data(&self) -> Option<&TokenData> {
         match self {
-            OutputValue::Coin(_) => None,
+            OutputValue::Coin(_) | OutputValue::TokenV1(_) => None,
             OutputValue::Token(d) => Some(d),
         }
     }

common/src/chain/transaction/signature/tests/mod.rs

@@ -711,6 +711,9 @@ fn add_value(output_value: OutputValue) -> OutputValue {
     match output_value {
         OutputValue::Coin(v) => OutputValue::Coin((v + Amount::from_atoms(100)).unwrap()),
         OutputValue::Token(v) => OutputValue::Token(v),
+        OutputValue::TokenV1((d, v)) => {
+            OutputValue::TokenV1((d, (v + Amount::from_atoms(100)).unwrap()))
+        }
     }
 }
 

common/src/chain/transaction/signature/tests/sign_and_mutate.rs

@@ -17,11 +17,10 @@ use itertools::Itertools;
 use rstest::rstest;
 use test_utils::random::Seed;
 
-use super::utils::*;
+use super::{add_value, utils::*};
 use crate::{
     chain::{
         config::create_mainnet,
-        output_value::OutputValue,
         signature::{
             sighash::sighashtype::{OutputsMode, SigHashType},
             tests::{
@@ -1059,13 +1058,6 @@ fn add_output(_rng: &mut impl Rng, tx: &SignedTransactionWithUtxo) -> SignedTran
     }
 }
 
-fn add_value(output_value: OutputValue) -> OutputValue {
-    match output_value {
-        OutputValue::Coin(v) => OutputValue::Coin((v + Amount::from_atoms(100)).unwrap()),
-        OutputValue::Token(v) => OutputValue::Token(v),
-    }
-}
-
 fn mutate_output(_rng: &mut impl Rng, tx: &SignedTransactionWithUtxo) -> SignedTransactionWithUtxo {
     let mut updater = MutableTransaction::from(&tx.tx);
     // Should fail due to change in output value

mempool/src/pool/tests/utils.rs

@@ -199,10 +199,7 @@ fn output_coin_amount(output: &TxOutput) -> Amount {
         TxOutput::LockThenTransfer(val, _, _) => val,
         _ => return Amount::ZERO,
     };
-    match val {
-        OutputValue::Coin(amt) => *amt,
-        OutputValue::Token(_) => Amount::ZERO,
-    }
+    val.coin_amount().unwrap_or(Amount::ZERO)
 }
 
 pub fn make_tx(

wallet/src/account/mod.rs

@@ -1214,6 +1214,12 @@ fn group_outputs<T, Grouped: Clone>(
                     TokenData::TokenIssuance(_) | TokenData::NftIssuance(_) => {}
                 }
             }
+            OutputValue::TokenV1((id, amount)) => {
+                let total_token_amount =
+                    tokens_grouped.entry(Currency::Token(id)).or_insert_with(|| init.clone());
+
+                combiner(total_token_amount, &output, amount)?;
+            }
         }
     }
 
@@ -1280,6 +1286,12 @@ fn group_utxos_for_input<T, Grouped: Clone>(
                     }
                 }
             }
+            OutputValue::TokenV1((id, amount)) => {
+                let total_token_amount =
+                    tokens_grouped.entry(Currency::Token(id)).or_insert_with(|| init.clone());
+
+                combiner(total_token_amount, &output, amount)?;
+            }
         }
     }
 

wallet/src/account/utxo_selector/output_group.rs

@@ -77,6 +77,7 @@ impl OutputGroup {
                     TokenData::NftIssuance(_) => Amount::from_atoms(1),
                 }
             }
+            OutputValue::TokenV1((_, output_amount)) => output_amount,
         };
 
         Ok(Self {