chore(examples): some cleanup around sending iota examples

bindings/go/examples/prepare_send_iota/main.go

@@ -36,12 +36,12 @@ func main() {
 	skipChecks := bool(false)
 	res, err := client.DryRunTx(txn, &skipChecks)
 	if err.(*sdk.SdkFfiError) != nil {
-		log.Fatalf("Failed to send IOTA: %v", err)
+		log.Fatalf("Dry run failed: %v", err)
 	}
 
 	if res.Error != nil {
-		log.Fatalf("Failed to send IOTA: %v", *res.Error)
+		log.Fatalf("Dry run failed: %v", *res.Error)
 	}
 
-	log.Print("Send IOTA dry run was successful!")
+	log.Print("Dry run successful!")
 }

bindings/go/examples/prepare_send_iota_multi/main.go

@@ -58,10 +58,10 @@ func main() {
 	skipChecks := bool(false)
 	res, err := client.DryRunTx(txn, &skipChecks)
 	if err.(*sdk.SdkFfiError) != nil {
-		log.Fatalf("Failed to dry run send IOTA: %v", err)
+		log.Fatalf("Dry run failed: %v", err)
 	}
 	if res.Error != nil {
-		log.Fatalf("Failed to send IOTA: %v", *res.Error)
+		log.Fatalf("Dry run failed: %v", *res.Error)
 	}
-	log.Print("Send IOTA dry run was successful!")
+	log.Print("Dry run successful!")
 }

bindings/go/examples/send_iota/main.go

@@ -0,0 +1,45 @@
+// Copyright (c) 2025 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+package main
+
+import (
+	"log"
+
+	sdk "bindings/iota_sdk_ffi"
+)
+
+func main() {
+	client := sdk.GraphQlClientNewDevnet()
+
+	sender, _ := sdk.AddressFromHex("0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c")
+	recipient, _ := sdk.AddressFromHex("0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900")
+
+	var amount = uint64(1_000_000_000)
+	builder := sdk.TransactionBuilderInit(sender, client)
+	builder.SendIota(recipient, &amount)
+
+	txn, err := builder.Finish()
+	if err.(*sdk.SdkFfiError) != nil {
+		log.Fatalf("Failed to create transaction: %v", err)
+	}
+
+	txnBytes, err := txn.BcsSerialize()
+	if err != nil {
+		log.Fatalf("Failed to serialize transaction: %v", err)
+	}
+	log.Printf("Signing Digest: %v", sdk.HexEncode(txn.SigningDigest()))
+	log.Printf("Txn Bytes: %v", sdk.Base64Encode(txnBytes))
+
+	skipChecks := bool(false)
+	res, err := client.DryRunTx(txn, &skipChecks)
+	if err.(*sdk.SdkFfiError) != nil {
+		log.Fatalf("Dry run failed: %v", err)
+	}
+
+	if res.Error != nil {
+		log.Fatalf("Dry run failed: %v", *res.Error)
+	}
+
+	log.Print("Dry run successful!")
+}

bindings/kotlin/examples/PrepareSendIota.kt

@@ -38,10 +38,10 @@ fun main() = runBlocking {
         val res = builder.dryRun()
 
         if (res.error != null) {
-            throw Exception("Failed to send IOTA: ${res.error}")
+            throw Exception("Dry run failed: ${res.error}")
         }
 
-        println("Send IOTA dry run was successful!")
+        println("Dry run successful!")
     } catch (e: Exception) {
         e.printStackTrace()
     }

bindings/kotlin/examples/PrepareSendIotaMulti.kt

@@ -62,10 +62,10 @@ fun main() = runBlocking {
         val res = builder.dryRun()
 
         if (res.error != null) {
-            throw Exception("Failed to send IOTA: ${res.error}")
+            throw Exception("Dry run failed: ${res.error}")
         }
 
-        println("Send IOTA dry run was successful!")
+        println("Dry run successful!")
     } catch (e: Exception) {
         e.printStackTrace()
     }

bindings/kotlin/examples/SendIota.kt

@@ -0,0 +1,39 @@
+// Copyright (c) 2025 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+import iota_sdk.*
+import kotlinx.coroutines.runBlocking
+
+fun main() = runBlocking {
+    try {
+        val client = GraphQlClient.newDevnet()
+
+        val sender =
+                Address.fromHex(
+                        "0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c"
+                )
+        val recipient =
+                Address.fromHex(
+                        "0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900"
+                )
+
+        val builder = TransactionBuilder.init(sender, client)
+
+        builder.sendIota(recipient, 1_000_000_000UL)
+
+        val txn = builder.finish()
+
+        println("Signing Digest: ${hexEncode(txn.signingDigest())}")
+        println("Txn Bytes: ${base64Encode(txn.bcsSerialize())}")
+
+        val res = builder.dryRun()
+
+        if (res.error != null) {
+            throw Exception("Dry run failed: ${res.error}")
+        }
+
+        println("Dry run successful!")
+    } catch (e: Exception) {
+        e.printStackTrace()
+    }
+}

bindings/python/examples/prepare_send_iota.py

@@ -10,21 +10,21 @@ async def main():
     try:
         client = GraphQlClient.new_devnet()
 
-        from_address = Address.from_hex(
+        sender = Address.from_hex(
             "0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c"
         )
 
-        to_address = Address.from_hex(
+        recipient = Address.from_hex(
             "0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900"
         )
 
         coin_id = ObjectId.from_hex(
             "0xd04077fe3b6fad13b3d4ed0d535b7ca92afcac8f0f2a0e0925fb9f4f0b30c699"
         )
 
-        builder = await TransactionBuilder.init(from_address, client)
+        builder = await TransactionBuilder.init(sender, client)
         builder.transfer_objects(
-            to_address,
+            recipient,
             [PtbArgument.object_id(coin_id)],
         )
 
@@ -33,11 +33,12 @@ async def main():
         print("Signing Digest:", hex_encode(txn.signing_digest()))
         print("Txn Bytes:", base64_encode(txn.bcs_serialize()))
 
+        print("Sending ")
         res = await client.dry_run_tx(txn)
         if res.error is not None:
-            raise Exception("Failed to send IOTA:", res.error)
+            raise Exception("Dry run failed:", res.error)
 
-        print("Send IOTA dry run was successful!")
+        print("Dry run successful!")
 
     except Exception as e:
         print(f"Error: {e}")

bindings/python/examples/prepare_send_iota_multi.py

@@ -8,13 +8,10 @@
 
 async def main():
     client = GraphQlClient.new_devnet()
+
     sender = Address.from_hex(
         "0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c"
     )
-    coin_id = ObjectId.from_hex(
-        "0x0b0270ee9d27da0db09651e5f7338dfa32c7ee6441ccefa1f6e305735bcfc7ab"
-    )
-
     recipients = [
         (
             "0x111173a14c3d402c01546c54265c30cc04414c7b7ec1732412bb19066dd49d11",
@@ -26,6 +23,10 @@ async def main():
         ),
     ]
 
+    coin_id = ObjectId.from_hex(
+        "0x0b0270ee9d27da0db09651e5f7338dfa32c7ee6441ccefa1f6e305735bcfc7ab"
+    )
+
     amounts = [r[1] for r in recipients]
     labels = [f"coin{i}" for i in range(len(recipients))]
 
@@ -43,9 +44,9 @@ async def main():
     res = await client.dry_run_tx(txn)
 
     if res.error is not None:
-        raise Exception(f"Failed to send IOTA: {res.error}")
+        raise Exception("Dry run failed:", res.error)
 
-    print("Send IOTA dry run was successful!")
+    print("Dry run successful!")
 
 
 if __name__ == "__main__":

bindings/python/examples/send_iota.py

@@ -0,0 +1,39 @@
+# Copyright (c) 2025 IOTA Stiftung
+# SPDX-License-Identifier: Apache-2.0
+
+from lib.iota_sdk_ffi import *
+
+import asyncio
+
+
+async def main():
+    try:
+        client = GraphQlClient.new_devnet()
+
+        sender = Address.from_hex(
+            "0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c"
+        )
+        recipient = Address.from_hex(
+            "0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900"
+        )
+
+        builder = await TransactionBuilder.init(sender, client)
+        builder.send_iota(recipient, 1_000_000_000)
+
+        txn = await builder.finish()
+
+        print("Signing Digest:", hex_encode(txn.signing_digest()))
+        print("Txn Bytes:", base64_encode(txn.bcs_serialize()))
+
+        res = await client.dry_run_tx(txn)
+        if res.error is not None:
+            raise Exception("Dry run failed:", res.error)
+
+        print("Dry run successful!")
+
+    except Exception as e:
+        print(f"Error: {e}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

crates/iota-graphql-client/examples/prepare_send_iota.rs

@@ -1,28 +1,24 @@
 // Copyright (c) 2025 IOTA Stiftung
 // SPDX-License-Identifier: Apache-2.0
 
-use std::str::FromStr;
-
 use base64ct::Encoding;
-use eyre::Result;
+use eyre::{Result, bail};
 use iota_graphql_client::Client;
 use iota_transaction_builder::TransactionBuilder;
-use iota_types::{Address, ObjectId};
+use iota_types::ObjectId;
 
 #[tokio::main]
 async fn main() -> Result<()> {
     let client = Client::new_devnet();
 
-    let from_address =
-        Address::from_str("0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c")?;
-    let to_address =
-        Address::from_str("0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900")?;
+    let sender = "0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c".parse()?;
+    let recipient = "0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900".parse()?;
 
-    let mut builder = TransactionBuilder::new(from_address).with_client(client.clone());
+    let mut builder = TransactionBuilder::new(sender).with_client(client.clone());
 
     builder.transfer_objects(
-        to_address,
-        ObjectId::from_str("0xd04077fe3b6fad13b3d4ed0d535b7ca92afcac8f0f2a0e0925fb9f4f0b30c699")?,
+        recipient,
+        "0xd04077fe3b6fad13b3d4ed0d535b7ca92afcac8f0f2a0e0925fb9f4f0b30c699".parse::<ObjectId>()?,
     );
 
     let txn = builder.finish().await?;
@@ -36,10 +32,10 @@ async fn main() -> Result<()> {
     let res = client.dry_run_tx(&txn, false).await?;
 
     if let Some(err) = res.error {
-        eyre::bail!("Failed to send IOTA: {err}");
+        bail!("Dry run failed: {err}");
     }
 
-    println!("Send IOTA dry run was successful!");
+    println!("Dry run successful!");
 
     Ok(())
 }

crates/iota-graphql-client/examples/prepare_send_iota_multi.rs

@@ -1,23 +1,18 @@
 // Copyright (c) 2025 IOTA Stiftung
 // SPDX-License-Identifier: Apache-2.0
 
-use std::str::FromStr;
-
 use base64ct::Encoding;
-use eyre::Result;
+use eyre::{Result, bail};
 use iota_graphql_client::Client;
 use iota_transaction_builder::{TransactionBuilder, res};
-use iota_types::{Address, ObjectId};
+use iota_types::Address;
 
 #[tokio::main]
 async fn main() -> Result<()> {
     let client = Client::new_devnet();
 
-    let coin =
-        ObjectId::from_str("0x0b0270ee9d27da0db09651e5f7338dfa32c7ee6441ccefa1f6e305735bcfc7ab")?;
-
-    let sender =
-        Address::from_str("0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c")?;
+    let coin = "0x0b0270ee9d27da0db09651e5f7338dfa32c7ee6441ccefa1f6e305735bcfc7ab".parse()?;
+    let sender = "0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c".parse()?;
 
     // Recipients and amounts
     let recipients = [
@@ -42,7 +37,7 @@ async fn main() -> Result<()> {
 
     // Transfer each split coin to the corresponding recipient
     for (i, (address, _)) in recipients.iter().enumerate() {
-        builder.transfer_objects(Address::from_str(address)?, res(&labels[i]));
+        builder.transfer_objects(Address::from_hex(address)?, res(&labels[i]));
     }
 
     let txn = builder.finish().await?;
@@ -56,10 +51,10 @@ async fn main() -> Result<()> {
     let res = client.dry_run_tx(&txn, false).await?;
 
     if let Some(err) = res.error {
-        eyre::bail!("Failed to send IOTA: {err}");
+        bail!("Dry run failed: {err}");
     }
 
-    println!("Send IOTA dry run was successful!");
+    println!("Dry run successful!");
 
     Ok(())
 }

crates/iota-graphql-client/examples/send_iota.rs

@@ -0,0 +1,37 @@
+// Copyright (c) 2025 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+use base64ct::Encoding;
+use eyre::{Result, bail};
+use iota_graphql_client::Client;
+use iota_transaction_builder::TransactionBuilder;
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    let client = Client::new_devnet();
+
+    let sender = "0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c".parse()?;
+    let recipient = "0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900".parse()?;
+
+    let mut builder = TransactionBuilder::new(sender).with_client(client.clone());
+
+    builder.send_iota(recipient, 1_000_000_000);
+
+    let txn = builder.finish().await?;
+
+    println!("Signing Digest: {}", hex::encode(txn.signing_digest()));
+    println!(
+        "Txn Bytes: {}",
+        base64ct::Base64::encode_string(&bcs::to_bytes(&txn)?)
+    );
+
+    let res = client.dry_run_tx(&txn, false).await?;
+
+    if let Some(err) = res.error {
+        bail!("Dry run failed: {err}");
+    }
+
+    println!("Dry run successful!");
+
+    Ok(())
+}