iotaledger · DaughterOfMars · Oct 8, 2025 · Oct 8, 2025
diff --git a/bindings/go/examples/prepare_send_iota/main.go b/bindings/go/examples/prepare_send_iota/main.go
@@ -15,11 +15,10 @@ func main() {
 	fromAddress, _ := sdk.AddressFromHex("0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c")
 
 	toAddress, _ := sdk.AddressFromHex("0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900")
-
-	coinObjId, _ := sdk.ObjectIdFromHex("0xd04077fe3b6fad13b3d4ed0d535b7ca92afcac8f0f2a0e0925fb9f4f0b30c699")
+	amount := uint64(5000000000)
 
 	builder := sdk.TransactionBuilderInit(fromAddress, client)
-	builder.TransferObjects(toAddress, []*sdk.PtbArgument{sdk.PtbArgumentObjectId(coinObjId)})
+	builder.SendIota(toAddress, &amount)
 
 	txn, err := builder.Finish()
 	if err.(*sdk.SdkFfiError) != nil {

diff --git a/bindings/go/examples/prepare_transfer_objects/main.go b/bindings/go/examples/prepare_transfer_objects/main.go
@@ -0,0 +1,59 @@
+// Copyright (c) 2025 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+package main
+
+import (
+	"log"
+
+	sdk "bindings/iota_sdk_ffi"
+)
+
+func objIdFromHex(hex string) *sdk.ObjectId {
+	id, err := sdk.ObjectIdFromHex(hex)
+	if err != nil {
+		log.Fatalf("Failed to parse object ID: %v", err)
+	}
+	return id
+}
+
+func main() {
+	client := sdk.GraphQlClientNewDevnet()
+
+	fromAddress, _ := sdk.AddressFromHex("0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c")
+
+	toAddress, _ := sdk.AddressFromHex("0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900")
+
+	objsToTransfer := []*sdk.PtbArgument{
+		sdk.PtbArgumentObjectId(objIdFromHex("0xd04077fe3b6fad13b3d4ed0d535b7ca92afcac8f0f2a0e0925fb9f4f0b30c699")),
+		sdk.PtbArgumentObjectId(objIdFromHex("0x0b0270ee9d27da0db09651e5f7338dfa32c7ee6441ccefa1f6e305735bcfc7ab")),
+		sdk.PtbArgumentObjectId(objIdFromHex("0x8ef4259fa2a3499826fa4b8aebeb1d8e478cf5397d05361c96438940b43d28c9")),
+	}
+
+	builder := sdk.TransactionBuilderInit(fromAddress, client)
+	builder.TransferObjects(toAddress, objsToTransfer)
+
+	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("Failed to transfer objects: %v", err)
+	}
+
+	if res.Error != nil {
+		log.Fatalf("Failed to transfer objects: %v", *res.Error)
+	}
+
+	log.Print("Transfer objects dry run was successful!")
+}
diff --git a/bindings/kotlin/examples/PrepareSendIota.kt b/bindings/kotlin/examples/PrepareSendIota.kt
@@ -18,16 +18,11 @@ fun main() = runBlocking {
                         "0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900"
                 )
 
-        val coinId =
-                ObjectId.fromHex(
-                        "0xd04077fe3b6fad13b3d4ed0d535b7ca92afcac8f0f2a0e0925fb9f4f0b30c699"
-                )
-
         val builder = TransactionBuilder.init(fromAddress, client)
 
-        builder.transferObjects(
+        builder.sendIota(
                 toAddress,
-                listOf(PtbArgument.objectId(coinId)),
+                5000000000uL,
         )
 
         val txn = builder.finish()

diff --git a/bindings/kotlin/examples/PrepareTransferObjects.kt b/bindings/kotlin/examples/PrepareTransferObjects.kt
@@ -0,0 +1,57 @@
+// 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 fromAddress =
+                Address.fromHex(
+                        "0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c"
+                )
+        val toAddress =
+                Address.fromHex(
+                        "0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900"
+                )
+        val objsToTransfer =
+                listOf(
+                        PtbArgument.objectId(
+                                ObjectId.fromHex(
+                                        "0xd04077fe3b6fad13b3d4ed0d535b7ca92afcac8f0f2a0e0925fb9f4f0b30c699"
+                                )
+                        ),
+                        PtbArgument.objectId(
+                                ObjectId.fromHex(
+                                        "0x0b0270ee9d27da0db09651e5f7338dfa32c7ee6441ccefa1f6e305735bcfc7ab"
+                                )
+                        ),
+                        PtbArgument.objectId(
+                                ObjectId.fromHex(
+                                        "0x8ef4259fa2a3499826fa4b8aebeb1d8e478cf5397d05361c96438940b43d28c9"
+                                )
+                        )
+                )
+
+        val builder = TransactionBuilder.init(fromAddress, client)
+
+        builder.transferObjects(toAddress, objsToTransfer)
+
+        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("Failed to transfer objects: ${res.error}")
+        }
+
+        println("Transfer objects dry run was successful!")
+    } catch (e: Exception) {
+        e.printStackTrace()
+    }
+}
diff --git a/bindings/python/examples/prepare_send_iota.py b/bindings/python/examples/prepare_send_iota.py
@@ -18,15 +18,8 @@ async def main():
             "0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900"
         )
 
-        coin_id = ObjectId.from_hex(
-            "0xd04077fe3b6fad13b3d4ed0d535b7ca92afcac8f0f2a0e0925fb9f4f0b30c699"
-        )
-
         builder = await TransactionBuilder.init(from_address, client)
-        builder.transfer_objects(
-            to_address,
-            [PtbArgument.object_id(coin_id)],
-        )
+        builder.send_iota(to_address, 5000000000)
 
         txn = await builder.finish()
 

diff --git a/bindings/python/examples/prepare_transfer_objects.py b/bindings/python/examples/prepare_transfer_objects.py
@@ -0,0 +1,59 @@
+# 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()
+
+        from_address = Address.from_hex(
+            "0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c"
+        )
+        to_address = Address.from_hex(
+            "0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900"
+        )
+        objs_to_transfer = [
+            PtbArgument.object_id(
+                ObjectId.from_hex(
+                    "0xd04077fe3b6fad13b3d4ed0d535b7ca92afcac8f0f2a0e0925fb9f4f0b30c699"
+                )
+            ),
+            PtbArgument.object_id(
+                ObjectId.from_hex(
+                    "0x0b0270ee9d27da0db09651e5f7338dfa32c7ee6441ccefa1f6e305735bcfc7ab"
+                )
+            ),
+            PtbArgument.object_id(
+                ObjectId.from_hex(
+                    "0x8ef4259fa2a3499826fa4b8aebeb1d8e478cf5397d05361c96438940b43d28c9"
+                )
+            ),
+        ]
+
+        builder = await TransactionBuilder.init(from_address, client)
+        builder.transfer_objects(
+            to_address,
+            objs_to_transfer,
+        )
+
+        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("Failed to transfer objects:", res.error)
+
+        print("Transfer objects dry run was successful!")
+
+    except Exception as e:
+        print(f"Error: {e}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/crates/iota-graphql-client/examples/prepare_send_iota.rs b/crates/iota-graphql-client/examples/prepare_send_iota.rs
@@ -7,7 +7,7 @@ use base64ct::Encoding;
 use eyre::Result;
 use iota_graphql_client::Client;
 use iota_transaction_builder::TransactionBuilder;
-use iota_types::{Address, ObjectId};
+use iota_types::Address;
 
 #[tokio::main]
 async fn main() -> Result<()> {
@@ -20,10 +20,7 @@ async fn main() -> Result<()> {
 
     let mut builder = TransactionBuilder::new(from_address).with_client(client.clone());
 
-    builder.transfer_objects(
-        to_address,
-        ObjectId::from_str("0xd04077fe3b6fad13b3d4ed0d535b7ca92afcac8f0f2a0e0925fb9f4f0b30c699")?,
-    );
+    builder.send_iota(to_address, 5000000000);
 
     let txn = builder.finish().await?;
 

diff --git a/crates/iota-graphql-client/examples/prepare_transfer_objects.rs b/crates/iota-graphql-client/examples/prepare_transfer_objects.rs
@@ -0,0 +1,47 @@
+// Copyright (c) 2025 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+use std::str::FromStr;
+
+use base64ct::Encoding;
+use eyre::Result;
+use iota_graphql_client::Client;
+use iota_transaction_builder::TransactionBuilder;
+use iota_types::{Address, 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 objs_to_transfer = [
+        ObjectId::from_str("0xd04077fe3b6fad13b3d4ed0d535b7ca92afcac8f0f2a0e0925fb9f4f0b30c699")?,
+        ObjectId::from_str("0x0b0270ee9d27da0db09651e5f7338dfa32c7ee6441ccefa1f6e305735bcfc7ab")?,
+        ObjectId::from_str("0x8ef4259fa2a3499826fa4b8aebeb1d8e478cf5397d05361c96438940b43d28c9")?,
+    ];
+
+    let mut builder = TransactionBuilder::new(from_address).with_client(client.clone());
+
+    builder.transfer_objects(to_address, objs_to_transfer);
+
+    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 {
+        eyre::bail!("Failed to transfer objects: {err}");
+    }
+
+    println!("Transfer objects dry run was successful!");
+
+    Ok(())
+}