Fix: foundry destroy example

sdk/CHANGELOG.md

@@ -26,6 +26,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `Wallet::get_or_create_account` convenience method;
 - `Output::kind_str()` method;
 - `ConflictReason` display implementation with an explanation of the conflict;
+- `TokenScheme` methods `is_simple` and `as_simple`;
 
 ### Changed
 

sdk/examples/how_tos/native_tokens/destroy_foundry.rs

@@ -12,7 +12,11 @@
 //! cargo run --release --all-features --example destroy_foundry
 //! ```
 
-use iota_sdk::{wallet::Result, Wallet};
+use iota_sdk::{
+    types::block::output::TokenId,
+    wallet::{account::types::NativeTokensBalance, Result},
+    Wallet,
+};
 
 #[tokio::main]
 async fn main() -> Result<()> {
@@ -34,12 +38,51 @@ async fn main() -> Result<()> {
         let foundry_count = balance.foundries().len();
         println!("Foundries before destroying: {foundry_count}");
 
+        let token_id = TokenId::from(*foundry_id);
+
         // Set the stronghold password
         wallet
             .set_stronghold_password(std::env::var("STRONGHOLD_PASSWORD").unwrap())
             .await?;
 
-        let transaction = account.burn(*foundry_id, None).await?;
+        // Find the native tokens balance for this foundry if one exists.
+        let native_tokens: Option<&NativeTokensBalance> = balance
+            .native_tokens()
+            .iter()
+            .find(|native_token| *native_token.token_id() == token_id);
+        if let Some(native_token) = native_tokens {
+            let output = account.get_foundry_output(token_id).await?;
+            // Check if all tokens are melted.
+            if native_token.available() != output.as_foundry().token_scheme().as_simple().circulating_supply() {
+                // We are not able to melt all tokens, because we dont own them or they are not unlocked.
+                println!("We dont own all remaining tokens, aborting foundry destruction.");
+                return Ok(());
+            }
+
+            println!("Melting remaining tokens..");
+            // Melt all tokens so we can destroy the foundry.
+            let transaction = account
+                .melt_native_token(token_id, native_token.available(), None)
+                .await?;
+            println!("Transaction sent: {}", transaction.transaction_id);
+
+            let block_id = account
+                .retry_transaction_until_included(&transaction.transaction_id, None, None)
+                .await?;
+            println!(
+                "Block included: {}/block/{}",
+                std::env::var("EXPLORER_URL").unwrap(),
+                block_id
+            );
+
+            // Sync to make the foundry output available again, because it was used in the melting transaction.
+            account.sync(None).await?;
+        }
+        println!("Destroying foundry..");
+
+        let transaction = account.prepare_burn(*foundry_id, None).await?;
+
+        let transaction = account.sign_and_submit_transaction(transaction, None).await?;
         println!("Transaction sent: {}", transaction.transaction_id);
 
         let block_id = account
@@ -51,6 +94,8 @@ async fn main() -> Result<()> {
             block_id
         );
 
+        // Resync to update the foundries list.
+        let balance = account.sync(None).await?;
         let foundry_count = balance.foundries().len();
         println!("Foundries after destroying: {foundry_count}");
     } else {

sdk/src/types/block/output/token_scheme/mod.rs

@@ -31,6 +31,18 @@ impl TokenScheme {
             Self::Simple(_) => SimpleTokenScheme::KIND,
         }
     }
+
+    /// Checks whether the token scheme is a [`SimpleTokenScheme`].
+    pub fn is_simple(&self) -> bool {
+        matches!(self, Self::Simple(_))
+    }
+
+    /// Gets the token scheme as an actual [`SimpleTokenScheme`].
+    /// PANIC: do not call on a non-simple token scheme.
+    pub fn as_simple(&self) -> &SimpleTokenScheme {
+        let Self::Simple(scheme) = self;
+        scheme
+    }
 }
 
 pub(crate) mod dto {