Fix and add tests for change token supply in the wallet

Author: OBorce

test/functional/test_framework/wallet_cli_controller.py

@@ -178,13 +178,23 @@ async def issue_new_token(self,
                               amount_to_issue: str,
                               number_of_decimals: int,
                               metadata_uri: str,
-                              destination_address: str) -> Tuple[Optional[str], Optional[str]]:
-        output = await self._write_command(f'issuenewtoken "{token_ticker}" "{amount_to_issue}" "{number_of_decimals}" "{metadata_uri}" {destination_address}\n')
+                              destination_address: str,
+                              token_supply: str = 'unlimited') -> Tuple[Optional[str], Optional[str]]:
+        output = await self._write_command(f'issuenewtoken "{token_ticker}" "{amount_to_issue}" "{number_of_decimals}" "{metadata_uri}" {destination_address} {token_supply}\n')
         if output.startswith("A new token has been issued with ID"):
             return output[output.find(':')+2:], None
 
         return None, output
 
+    async def mint_tokens(self, token_id: str, address: str, amount: int) -> str:
+        return await self._write_command(f"minttokens {token_id} {address} {amount}\n")
+
+    async def redeem_tokens(self, token_id: str, amount: int) -> str:
+        return await self._write_command(f"redeemtokens {token_id} {amount}\n")
+
+    async def lock_tokens(self, token_id: str) -> str:
+        return await self._write_command(f"locktokens {token_id}\n")
+
     async def issue_new_nft(self,
                             destination_address: str,
                             media_hash: str,

test/functional/test_runner.py

@@ -131,6 +131,7 @@ class UnicodeOnWindowsError(ValueError):
     'wallet_recover_accounts.py',
     'wallet_get_address_usage.py',
     'wallet_tokens.py',
+    'wallet_tokens_change_supply.py',
     'wallet_nfts.py',
     'wallet_delegations.py',
     'wallet_high_fee.py',

test/functional/wallet_tokens.py

@@ -31,7 +31,7 @@
 from test_framework.mintlayer import (make_tx, reward_input, tx_input, ATOMS_PER_COIN)
 from test_framework.util import assert_in, assert_equal
 from test_framework.mintlayer import mintlayer_hash, block_input_data_obj
-from test_framework.wallet_cli_controller import WalletCliController
+from test_framework.wallet_cli_controller import DEFAULT_ACCOUNT_INDEX, WalletCliController
 
 import asyncio
 import sys
@@ -90,7 +90,7 @@ async def async_test(self):
 
             # Submit a valid transaction
             output = {
-                    'Transfer': [ { 'Coin': 101 * ATOMS_PER_COIN }, { 'PublicKey': {'key': {'Secp256k1Schnorr' : {'pubkey_data': pub_key_bytes}}} } ],
+                    'Transfer': [ { 'Coin': 201 * ATOMS_PER_COIN }, { 'PublicKey': {'key': {'Secp256k1Schnorr' : {'pubkey_data': pub_key_bytes}}} } ],
             }
             encoded_tx, tx_id = make_tx([reward_input(tip_id)], [output], 0)
 
@@ -107,7 +107,7 @@ async def async_test(self):
             assert_equal(await wallet.get_best_block_height(), '1')
             assert_equal(await wallet.get_best_block(), block_id)
 
-            assert_in("Coins amount: 101", await wallet.get_balance())
+            assert_in("Coins amount: 201", await wallet.get_balance())
 
             address = await wallet.new_address()
 
@@ -144,31 +144,33 @@ async def async_test(self):
             self.generate_block()
             assert_in("Success", await wallet.sync())
 
-            # TODO: add support for tokens v1
-            # Hint with tokens v1 they have to be minted before any could be sent
-            # See https://github.com/mintlayer/mintlayer-core/issues/1237
-            #assert_in(f"{token_id} amount: 10000", await wallet.get_balance())
+            assert_in("The transaction was submitted successfully", await wallet.mint_tokens(token_id, address, 10000))
+
+            self.generate_block()
+            assert_in("Success", await wallet.sync())
+
+            assert_in(f"{token_id} amount: 10000", await wallet.get_balance())
 
             ## create a new account and send some tokens to it
-            #await wallet.create_new_account()
-            #await wallet.select_account(1)
-            #address = await wallet.new_address()
+            await wallet.create_new_account()
+            await wallet.select_account(1)
+            address = await wallet.new_address()
 
-            #await wallet.select_account(0)
-            #output = await wallet.send_tokens_to_address(token_id, address, 10.01)
-            #assert_in("The transaction was submitted successfully", output)
+            await wallet.select_account(DEFAULT_ACCOUNT_INDEX)
+            output = await wallet.send_tokens_to_address(token_id, address, 10.01)
+            assert_in("The transaction was submitted successfully", output)
 
-            #self.generate_block()
-            #assert_in("Success", await wallet.sync())
+            self.generate_block()
+            assert_in("Success", await wallet.sync())
 
             ## check the new balance
-            #assert_in(f"{token_id} amount: 9989.99", await wallet.get_balance())
+            assert_in(f"{token_id} amount: 9989.99", await wallet.get_balance())
 
             ## try to issue a new token, should fail with not enough coins
-            #token_id, err = await wallet.issue_new_token("XXX", "10000", 2, "http://uri", address)
-            #assert token_id is None
-            #assert err is not None
-            #assert_in("Not enough funds", err)
+            token_id, err = await wallet.issue_new_token("XXX", "10000", 2, "http://uri", address)
+            assert token_id is None
+            assert err is not None
+            assert_in("Not enough funds", err)
 
 if __name__ == '__main__':
     WalletTokens().main()

wallet/src/account/mod.rs

@@ -261,6 +261,11 @@ impl Account {
 
         total_fees_not_paid =
             (total_fees_not_paid + preselected_fee).ok_or(WalletError::OutputAmountOverflow)?;
+        total_fees_not_paid = preselected_inputs
+            .values()
+            .try_fold(total_fees_not_paid, |total, (_amount, fee)| total + *fee)
+            .ok_or(WalletError::OutputAmountOverflow)?;
+
         let mut amount_to_be_paid_in_currency_with_fees = (amount_to_be_paid_in_currency_with_fees
             + total_fees_not_paid)
             .ok_or(WalletError::OutputAmountOverflow)?;
@@ -720,6 +725,8 @@ impl Account {
         let outputs =
             make_mint_token_outputs(token_id, amount, address, self.chain_config.as_ref())?;
 
+        self.find_token(&token_id)?.total_supply.check_can_mint(amount)?;
+
         self.change_token_supply_transaction(
             token_id,
             amount,
@@ -730,42 +737,6 @@ impl Account {
         )
     }
 
-    fn change_token_supply_transaction(
-        &mut self,
-        token_id: TokenId,
-        amount: Amount,
-        outputs: Vec<TxOutput>,
-        db_tx: &mut impl WalletStorageWriteUnlocked,
-        median_time: BlockTimestamp,
-        fee_rate: CurrentFeeRate,
-    ) -> Result<SignedTransaction, WalletError> {
-        let token_data = self.find_token(&token_id)?;
-        let nonce = token_data
-            .last_nonce
-            .map_or(Some(AccountNonce::new(0)), |nonce| nonce.increment())
-            .ok_or(WalletError::TokenIssuanceNonceOverflow(token_id))?;
-        let tx_input = TxInput::Account(AccountOutPoint::new(
-            nonce,
-            AccountSpending::TokenSupply(token_id, amount),
-        ));
-
-        let request = SendRequest::new()
-            .with_outputs(outputs)
-            .with_inputs_and_destinations([(tx_input, token_data.reissuance_controller.clone())]);
-
-        let request = self.select_inputs_for_send_request(
-            request,
-            vec![],
-            db_tx,
-            median_time,
-            fee_rate.current_fee_rate,
-            fee_rate.consolidate_fee_rate,
-        )?;
-
-        let tx = self.sign_transaction_from_req(request, db_tx)?;
-        Ok(tx)
-    }
-
     pub fn redeem_tokens(
         &mut self,
         db_tx: &mut impl WalletStorageWriteUnlocked,
@@ -776,6 +747,8 @@ impl Account {
     ) -> WalletResult<SignedTransaction> {
         let outputs = make_redeem_token_outputs(token_id, amount, self.chain_config.as_ref())?;
 
+        self.find_token(&token_id)?.total_supply.check_can_redeem(amount)?;
+
         self.change_token_supply_transaction(
             token_id,
             amount,
@@ -795,6 +768,8 @@ impl Account {
     ) -> WalletResult<SignedTransaction> {
         let outputs = make_lock_token_outputs(token_id, self.chain_config.as_ref())?;
 
+        self.find_token(&token_id)?.total_supply.check_can_lock()?;
+
         self.change_token_supply_transaction(
             token_id,
             Amount::ZERO,
@@ -805,6 +780,43 @@ impl Account {
         )
     }
 
+    fn change_token_supply_transaction(
+        &mut self,
+        token_id: TokenId,
+        amount: Amount,
+        outputs: Vec<TxOutput>,
+        db_tx: &mut impl WalletStorageWriteUnlocked,
+        median_time: BlockTimestamp,
+        fee_rate: CurrentFeeRate,
+    ) -> Result<SignedTransaction, WalletError> {
+        let token_data = self.find_token(&token_id)?;
+
+        let nonce = token_data
+            .last_nonce
+            .map_or(Some(AccountNonce::new(0)), |nonce| nonce.increment())
+            .ok_or(WalletError::TokenIssuanceNonceOverflow(token_id))?;
+        let tx_input = TxInput::Account(AccountOutPoint::new(
+            nonce,
+            AccountSpending::TokenSupply(token_id, amount),
+        ));
+
+        let request = SendRequest::new()
+            .with_outputs(outputs)
+            .with_inputs_and_destinations([(tx_input, token_data.reissuance_controller.clone())]);
+
+        let request = self.select_inputs_for_send_request(
+            request,
+            vec![],
+            db_tx,
+            median_time,
+            fee_rate.current_fee_rate,
+            fee_rate.consolidate_fee_rate,
+        )?;
+
+        let tx = self.sign_transaction_from_req(request, db_tx)?;
+        Ok(tx)
+    }
+
     pub fn get_pos_gen_block_data(
         &self,
         db_tx: &impl WalletStorageReadUnlocked,
@@ -1364,6 +1376,10 @@ impl Account {
     }
 }
 
+/// There are some preselected inputs like the Token account inputs with a nonce
+/// that need to be included in the request
+/// Here we group them up by currency and sum the total amount and fee they bring to the
+/// transaction
 fn group_preselected_inputs(
     request: &SendRequest,
     current_fee_rate: FeeRate,
@@ -1433,7 +1449,18 @@ fn group_outputs<T, Grouped: Clone>(
             }
             TxOutput::CreateStakePool(_, stake) => OutputValue::Coin(stake.value()),
             TxOutput::DelegateStaking(amount, _) => OutputValue::Coin(*amount),
-            TxOutput::TokensOp(_) | TxOutput::CreateDelegationId(_, _) => continue,
+            TxOutput::TokensOp(token_output) => match token_output {
+                TokenOutput::MintTokens(token_id, amount, _) => {
+                    OutputValue::TokenV1(*token_id, *amount)
+                }
+                TokenOutput::RedeemTokens(token_id, amount) => {
+                    OutputValue::TokenV1(*token_id, *amount)
+                }
+                TokenOutput::IssueFungibleToken(_)
+                | TokenOutput::IssueNft(_, _, _)
+                | TokenOutput::LockCirculatingSupply(_) => continue,
+            },
+            TxOutput::CreateDelegationId(_, _) => continue,
             TxOutput::ProduceBlockFromStake(_, _) => {
                 return Err(WalletError::UnsupportedTransactionOutput(Box::new(
                     get_tx_output(&output).clone(),