Implement mint_ft functionality in interpreter and console (#2033)

* implement mint_ft_balance in the interpreter; add a test which creates a ft via contract then uses the interpreter to mint while checking that the vm db knows about both the contract and interpreter mint events; add mint_ft session command which calls mint_ft_balance

use asset identifier instead of passing contract identifier and asset name separately; use sugared asset identifier as token name when calling credit_token so db and interpreter balances will match

remove unnecessary refs

add session test for mint_ft that runs the command via a passed string and verifies that balances are correct

add explicit test for failure cases in parse_asset_identifier

use enum for error type in parse_asset_identifier

test failure cases for Session::mint_ft

map errors to remove unwrap/expect in mint_ft_balance

remove unit let binding

pass metadata into get_ft_balance so the clarity vm db can skip loading it again

test that we fail to load_ft for an asset that doesn't exist

change bad amount to -1 so there's no chance of multiple failures cancelling each other out

* swap order of asset identifier and recipient address

* add mint_ft to display_help with an explanation of the asset identifier format

* let user skip the deployer part of the contract identifier; fix tests

* use indoc::formatdoc to make contract src pretty

* fix desugar_contract_id so it works with contracts that lead with a period

* collapse else/if into else if; swap order of deployer and identifier parameters

* rename deployer to default_deployer since it will always be that, but not always be the actual deployer of the contract

* fix missing rename

Author: xoloki-stacks

components/clarity-repl/src/repl/interpreter.rs

@@ -18,7 +18,9 @@ use clarity::vm::{
     eval, eval_all, ClarityVersion, ContractEvaluationResult, CostSynthesis, EvalHook,
     EvaluationResult, ExecutionResult, ParsedContract, SnippetEvaluationResult,
 };
-use clarity_types::types::{PrincipalData, QualifiedContractIdentifier, StandardPrincipalData};
+use clarity_types::types::{
+    AssetIdentifier, PrincipalData, QualifiedContractIdentifier, StandardPrincipalData,
+};
 use clarity_types::Value;
 
 use super::datastore::StacksConstants;
@@ -817,6 +819,66 @@ impl ClarityInterpreter {
         Ok(format!("→ {recipient}: {final_balance} µSTX"))
     }
 
+    pub fn mint_ft_balance(
+        &mut self,
+        asset_identifier: &AssetIdentifier,
+        recipient: &PrincipalData,
+        amount: u64,
+    ) -> Result<String, String> {
+        let contract_identifier = asset_identifier.contract_identifier.clone();
+        let token_name = asset_identifier.asset_name.to_string();
+        let final_balance = {
+            let mut global_context = self.get_global_context(DEFAULT_EPOCH, false)?;
+
+            global_context.begin();
+
+            let metadata = global_context
+                .database
+                .load_ft(&contract_identifier, &token_name)
+                .map_err(|e| {
+                    format!("failed to load_ft for {contract_identifier}.{token_name}: {e:?}")
+                })?;
+
+            let cur_balance = global_context
+                .database
+                .get_ft_balance(&contract_identifier, &token_name, recipient, Some(&metadata))
+                .map_err(|e| format!("failed to get_ft_balance for {contract_identifier}.{token_name} {recipient}: {e:?}"))?;
+
+            global_context.database.set_ft_balance(
+                &contract_identifier,
+                &token_name,
+                recipient,
+                cur_balance + amount as u128,
+            ).map_err(|e| format!("failed to set_ft_balance for {contract_identifier}.{token_name} {recipient}: {e:?}"))?;
+
+            let final_balance = global_context
+                .database
+                .get_ft_balance(&contract_identifier, &token_name, recipient, Some(&metadata))
+                .map_err(|e| format!("failed to get_ft_balance for {contract_identifier}.{token_name} {recipient}: {e:?}"))?;
+
+            global_context
+                .database
+                .checked_increase_token_supply(
+                    &contract_identifier,
+                    &token_name,
+                    amount as u128,
+                    &metadata,
+                )
+                .map_err(|e| format!("failed to increase token supply for {contract_identifier}.{token_name}: {e:?}"))?;
+
+            global_context
+                .commit()
+                .map_err(|e| format!("failed to commit ctx: {e:?}"))?;
+            final_balance
+        };
+        self.credit_token(
+            recipient.to_string(),
+            asset_identifier.sugared(),
+            amount.into(),
+        );
+        Ok(format!("→ {recipient}: {final_balance} {token_name}"))
+    }
+
     pub fn set_tx_sender(&mut self, tx_sender: StandardPrincipalData) {
         self.tx_sender = tx_sender;
     }
@@ -938,7 +1000,7 @@ mod tests {
     use clarity::util::hash::hex_bytes;
     use clarity::vm::{self, ClarityVersion};
     use clarity_types::types::TupleData;
-    use indoc::indoc;
+    use indoc::{formatdoc, indoc};
 
     use super::*;
     use crate::analysis::Settings as AnalysisSettings;
@@ -1173,6 +1235,112 @@ mod tests {
         assert_eq!(balance, amount.into());
     }
 
+    #[test]
+    fn test_mint_ft_balance() {
+        let mut interpreter = get_interpreter(None);
+        let recipient = PrincipalData::Standard(StandardPrincipalData::transient());
+        let token_name = "ctb";
+        let src = formatdoc!(
+            r#"
+            (define-fungible-token {token_name})
+            (define-private (test-mint)
+                (ft-mint? ctb u100 tx-sender))
+            (define-private (test-burn)
+                (ft-burn? ctb u10 tx-sender))
+            (define-private (test-transfer)
+                (ft-transfer? ctb u10 tx-sender (as-contract tx-sender)))
+            (define-private (test-burn-1000)
+                (ft-burn? ctb u1000 tx-sender))
+            (define-private (test-transfer-1000)
+                (ft-transfer? ctb u1000 tx-sender (as-contract tx-sender)))
+            (test-mint)
+            (test-burn)
+            (test-transfer)
+            (test-burn-1000)
+            (test-transfer-1000)"#
+        );
+
+        let contract = ClarityContractBuilder::default().code_source(src).build();
+        let deploy_result = deploy_contract(&mut interpreter, &contract);
+        assert!(deploy_result.is_ok());
+        let ExecutionResult {
+            diagnostics,
+            events,
+            result,
+            ..
+        } = deploy_result.unwrap();
+        assert!(diagnostics.is_empty());
+        assert_eq!(events.len(), 3);
+        assert!(matches!(
+            events[0],
+            StacksTransactionEvent::FTEvent(FTEventType::FTMintEvent(_))
+        ));
+        assert!(matches!(
+            events[1],
+            StacksTransactionEvent::FTEvent(FTEventType::FTBurnEvent(_))
+        ));
+        assert!(matches!(
+            events[2],
+            StacksTransactionEvent::FTEvent(FTEventType::FTTransferEvent(_))
+        ));
+
+        let contract_identifier_string =
+            if let EvaluationResult::Contract(contract_evaluation_result) = result {
+                contract_evaluation_result
+                    .contract
+                    .contract_identifier
+                    .clone()
+            } else {
+                panic!("didn't get EvaluationResult::Contract");
+            };
+
+        let contract_identifier =
+            QualifiedContractIdentifier::parse(&contract_identifier_string).unwrap();
+        let asset_identifier = AssetIdentifier {
+            contract_identifier: contract_identifier.clone(),
+            asset_name: token_name.into(),
+        };
+
+        let amount = 1000;
+
+        let result = interpreter.mint_ft_balance(&asset_identifier, &recipient.clone(), amount);
+        assert!(result.is_ok());
+
+        // in the contract we minted 100, burned 10, then transferred 10 to as-contract
+        // in the interpreter we minted 1000
+        // this should leave 1080 for recipient
+        let balance = interpreter
+            .get_balance_for_account(&recipient.to_string(), &asset_identifier.sugared());
+        assert_eq!(balance, 1080);
+
+        let mut global_context = interpreter
+            .get_global_context(DEFAULT_EPOCH, false)
+            .unwrap();
+
+        global_context.begin();
+
+        let supply = global_context
+            .database
+            .get_ft_supply(&contract_identifier, token_name)
+            .expect("failed to get ft supply");
+
+        // in the contract we minted 100 and burned 10
+        // in the interpreter we minted 1000
+        // this should leave 1090 total supply
+        assert_eq!(supply, 1090);
+
+        // if we used the correct token names everywhere the interpreter and db
+        // balances should match
+        let db_balance = global_context
+            .database
+            .get_ft_balance(&contract_identifier, token_name, &recipient, None)
+            .expect("failed to get ft balance");
+
+        assert_eq!(balance, db_balance);
+
+        global_context.commit().unwrap();
+    }
+
     #[test]
     fn test_run_valid_contract() {
         let mut interpreter = get_interpreter(None);

components/clarity-repl/src/repl/mod.rs

@@ -217,7 +217,7 @@ impl ClarityContract {
                 PrincipalData::parse_standard_principal(address).expect("unable to parse address")
             }
             ContractDeployer::DefaultDeployer => default_deployer
-                .expect("default provider should have been provided")
+                .expect("default deployer should have been provided")
                 .clone(),
             _ => panic!("deployer expected to be resolved"),
         };