Change tokens supply

Cargo.toml

@@ -53,6 +53,7 @@ members = [
   "test",                               # Integration tests.
   "test-rpc-functions",                 # RPC functions specifically for tests.
   "test-utils",                         # Various utilities for tests.
+  "tokens-accounting",                  # Tokens accounting
   "utils",                              # Various utilities.
   "utxo",                               # Utxo and related utilities (cache, undo, etc.).
   "wallet",                             # Wallet primitives.

blockprod/src/detail/tests.rs

@@ -23,7 +23,7 @@ use common::{
         stakelock::StakePoolData,
         transaction::TxInput,
         ConsensusUpgrade, Destination, GenBlock, Genesis, NetUpgrades, OutPointSourceId, PoolId,
-        RequiredConsensus, TxOutput, UpgradeVersion,
+        RequiredConsensus, TxOutput,
     },
     primitives::{per_thousand::PerThousand, time, Amount, BlockHeight, Id, H256},
     time_getter::TimeGetter,
@@ -999,16 +999,16 @@ mod produce_block {
         let override_chain_config = {
             let net_upgrades = NetUpgrades::initialize(vec![(
                 BlockHeight::new(0),
-                UpgradeVersion::ConsensusUpgrade(ConsensusUpgrade::PoW {
+                ConsensusUpgrade::PoW {
                     // Make difficulty impossible so the cancel from
                     // the mock job manager is always seen before
                     // solving the block
                     initial_difficulty: Uint256::ZERO.into(),
-                }),
+                },
             )])
             .expect("Net upgrade is valid");
 
-            Builder::new(ChainType::Regtest).net_upgrades(net_upgrades).build()
+            Builder::new(ChainType::Regtest).consensus_upgrades(net_upgrades).build()
         };
 
         let (manager, chain_config, chainstate, mempool, p2p) =
@@ -1128,13 +1128,13 @@ mod produce_block {
         let override_chain_config = {
             let net_upgrades = NetUpgrades::initialize(vec![(
                 BlockHeight::new(0),
-                UpgradeVersion::ConsensusUpgrade(ConsensusUpgrade::PoW {
+                ConsensusUpgrade::PoW {
                     initial_difficulty: Uint256::MAX.into(),
-                }),
+                },
             )])
             .expect("Net upgrade is valid");
 
-            Builder::new(ChainType::Regtest).net_upgrades(net_upgrades).build()
+            Builder::new(ChainType::Regtest).consensus_upgrades(net_upgrades).build()
         };
 
         let (manager, chain_config, chainstate, mempool, p2p) =
@@ -1312,10 +1312,8 @@ mod produce_block {
                 },
             ];
 
-            let mut randomized_net_upgrades = vec![(
-                BlockHeight::new(0),
-                UpgradeVersion::ConsensusUpgrade(ConsensusUpgrade::IgnoreConsensus),
-            )];
+            let mut randomized_net_upgrades =
+                vec![(BlockHeight::new(0), ConsensusUpgrade::IgnoreConsensus)];
 
             let mut next_height_consensus_change = 1;
 
@@ -1324,7 +1322,7 @@ mod produce_block {
 
                 randomized_net_upgrades.push((
                     BlockHeight::new(next_height_consensus_change),
-                    UpgradeVersion::ConsensusUpgrade(consensus_types[next_consensus_type].clone()),
+                    consensus_types[next_consensus_type].clone(),
                 ));
 
                 next_height_consensus_change += rng.gen_range(1..50);
@@ -1335,7 +1333,7 @@ mod produce_block {
 
             Builder::new(ChainType::Regtest)
                 .genesis_custom(genesis_block)
-                .net_upgrades(net_upgrades)
+                .consensus_upgrades(net_upgrades)
                 .build()
         };
 
@@ -1384,7 +1382,7 @@ mod produce_block {
                     ));
 
                     match chain_config
-                        .net_upgrade()
+                        .consensus_upgrades()
                         .consensus_status(BlockHeight::new(block_height))
                     {
                         RequiredConsensus::IgnoreConsensus => {

blockprod/src/lib.rs

@@ -131,7 +131,7 @@ mod tests {
             pos_initial_difficulty,
             stakelock::StakePoolData,
             Block, ConsensusUpgrade, Destination, Genesis, NetUpgrades, PoSChainConfigBuilder,
-            TxOutput, UpgradeVersion,
+            TxOutput,
         },
         primitives::{per_thousand::PerThousand, Amount, BlockHeight, Idable, H256},
         time_getter::TimeGetter,
@@ -324,23 +324,20 @@ mod tests {
             );
 
             let net_upgrades = NetUpgrades::initialize(vec![
-                (
-                    BlockHeight::new(0),
-                    UpgradeVersion::ConsensusUpgrade(ConsensusUpgrade::IgnoreConsensus),
-                ),
+                (BlockHeight::new(0), ConsensusUpgrade::IgnoreConsensus),
                 (
                     BlockHeight::new(1),
-                    UpgradeVersion::ConsensusUpgrade(ConsensusUpgrade::PoS {
+                    ConsensusUpgrade::PoS {
                         initial_difficulty: Some(pos_initial_difficulty(ChainType::Regtest).into()),
                         config: PoSChainConfigBuilder::new_for_unit_test().build(),
-                    }),
+                    },
                 ),
             ])
             .expect("Net upgrades are valid");
 
             Builder::new(ChainType::Regtest)
                 .genesis_custom(genesis_block)
-                .net_upgrades(net_upgrades)
+                .consensus_upgrades(net_upgrades)
                 .build()
         };
 

chainstate/Cargo.toml

@@ -17,6 +17,7 @@ rpc = {path = '../rpc'}
 serialization = {path = "../serialization"}
 subsystem = {path = '../subsystem'}
 tx-verifier = {path = './tx-verifier'}
+tokens-accounting = {path = '../tokens-accounting'}
 utils = {path = '../utils'}
 utxo = {path = '../utxo'}
 

chainstate/src/detail/ban_score.rs

@@ -74,6 +74,7 @@ impl BanScore for BlockError {
             BlockError::InvariantErrorFailedToFindNewChainPath(_, _, _) => 0,
             BlockError::InvariantErrorInvalidTip(_) => 0,
             BlockError::InvariantErrorAttemptToConnectInvalidBlock(_) => 0,
+            BlockError::TokensAccountingError(err) => err.ban_score(),
         }
     }
 }
@@ -149,6 +150,9 @@ impl BanScore for ConnectTransactionError {
             ConnectTransactionError::MissingTransactionNonce(_) => 100,
             ConnectTransactionError::FailedToIncrementAccountNonce => 0,
             ConnectTransactionError::IOPolicyError(err, _) => err.ban_score(),
+            ConnectTransactionError::TokensAccountingError(err) => err.ban_score(),
+            ConnectTransactionError::TokensAccountingBlockUndoError(_) => 100,
+            ConnectTransactionError::TotalFeeRequiredOverflow => 100,
         }
     }
 }
@@ -168,12 +172,14 @@ impl BanScore for SignatureDestinationGetterError {
         match self {
             SignatureDestinationGetterError::SpendingOutputInBlockReward => 100,
             SignatureDestinationGetterError::SpendingFromAccountInBlockReward => 100,
-            SignatureDestinationGetterError::SigVerifyOfBurnedOutput => 100,
+            SignatureDestinationGetterError::SigVerifyOfNotSpendableOutput => 100,
             SignatureDestinationGetterError::PoolDataNotFound(_) => 100,
             SignatureDestinationGetterError::DelegationDataNotFound(_) => 100,
             SignatureDestinationGetterError::SigVerifyPoSAccountingError(_) => 100,
             SignatureDestinationGetterError::UtxoOutputNotFound(_) => 100,
             SignatureDestinationGetterError::UtxoViewError(_) => 100,
+            SignatureDestinationGetterError::TokenDataNotFound(_) => 100,
+            SignatureDestinationGetterError::SigVerifyTokensAccountingError(_) => 100,
         }
     }
 }
@@ -192,6 +198,8 @@ impl BanScore for TransactionVerifierStorageError {
             TransactionVerifierStorageError::TransactionIndexDisabled => 0,
             TransactionVerifierStorageError::PoSAccountingError(err) => err.ban_score(),
             TransactionVerifierStorageError::AccountingBlockUndoError(_) => 100,
+            TransactionVerifierStorageError::TokensAccountingError(err) => err.ban_score(),
+            TransactionVerifierStorageError::TokensAccountingBlockUndoError(_) => 100,
         }
     }
 }
@@ -275,6 +283,8 @@ impl BanScore for TokensError {
             TokensError::TokensInBlockReward => 100,
             TokensError::InvariantBrokenUndoIssuanceOnNonexistentToken(_) => 100,
             TokensError::InvariantBrokenRegisterIssuanceWithDuplicateId(_) => 100,
+            TokensError::DeprecatedTokenOperationVersion(_, _) => 100,
+            TokensError::UnsupportedTokenIssuanceVersion(_, _) => 100,
         }
     }
 }
@@ -503,4 +513,26 @@ impl BanScore for IOPolicyError {
     }
 }
 
+impl BanScore for tokens_accounting::Error {
+    fn ban_score(&self) -> u32 {
+        match self {
+            tokens_accounting::Error::StorageError(_) => 0,
+            tokens_accounting::Error::AccountingError(_) => 100,
+            tokens_accounting::Error::TokenAlreadyExists(_) => 100,
+            tokens_accounting::Error::TokenDataNotFound(_) => 100,
+            tokens_accounting::Error::TokenDataNotFoundOnReversal(_) => 100,
+            tokens_accounting::Error::CirculatingSupplyNotFound(_) => 100,
+            tokens_accounting::Error::MintExceedsSupplyLimit(_, _, _) => 100,
+            tokens_accounting::Error::AmountOverflow => 100,
+            tokens_accounting::Error::CannotMintFromLockedSupply(_) => 100,
+            tokens_accounting::Error::CannotUnmintFromLockedSupply(_) => 100,
+            tokens_accounting::Error::NotEnoughCirculatingSupplyToUnmint(_, _, _) => 100,
+            tokens_accounting::Error::SupplyIsAlreadyLocked(_) => 100,
+            tokens_accounting::Error::CannotLockNotLockableSupply(_) => 100,
+            tokens_accounting::Error::ViewFail => 0,
+            tokens_accounting::Error::StorageWrite => 0,
+        }
+    }
+}
+
 // TODO: tests in which we simulate every possible case and test the score

chainstate/src/detail/chainstateref/epoch_seal.rs

@@ -167,7 +167,9 @@ where
         | TxOutput::LockThenTransfer(_, _, _)
         | TxOutput::Burn(_)
         | TxOutput::CreateDelegationId(_, _)
-        | TxOutput::DelegateStaking(_, _) => {
+        | TxOutput::DelegateStaking(_, _)
+        | TxOutput::IssueFungibleToken(_)
+        | TxOutput::IssueNft(_, _, _) => {
             return Err(EpochSealError::SpendStakeError(
                 SpendStakeError::InvalidBlockRewardOutputType,
             ));