chore(examples): add generic move function example (#199)

* add rs example

* add py example

* add go example

* add kotlin example

* fix typo

* raise exception

Author: Alex6323

bindings/go/examples/generic_move_function/main.go

@@ -0,0 +1,81 @@
+// Copyright (c) 2025 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+package main
+
+import (
+	"encoding/binary"
+	"fmt"
+	"log"
+
+	sdk "bindings/iota_sdk_ffi"
+)
+
+func main() {
+	client := sdk.GraphQlClientNewDevnet()
+
+	sender, _ := sdk.AddressFromHex("0x71b4b4f171b4355ff691b7c470579cf1a926f96f724e5f9a30efc4b5f75d085e")
+	gas_coin_id, _ := sdk.ObjectIdFromHex("0xa1d009e8dafe20b1cba05e08aea488aafae1f89d892c3eaef6c0994e155e441a")
+
+	gas_coin_obj, err := client.Object(gas_coin_id, nil)
+	if err.(*sdk.SdkFfiError) != nil {
+		log.Fatalf("Failed to fetch gas coin object: %v", err)
+	}
+	gas_coin := sdk.UnresolvedInputFromObject(*gas_coin_obj).WithOwnedKind()
+
+	reference_gas_price, err := client.ReferenceGasPrice(nil)
+	if err.(*sdk.SdkFfiError) != nil {
+		log.Fatalf("Failed to fetch reference gas price: %v", err)
+	}
+
+	builder := sdk.NewTransactionBuilder()
+
+	addr1, _ := sdk.AddressFromHex("0xde49ea53fbadee67d3e35a097cdbea210b659676fc680a0b0c5f11d0763d375e")
+	addr2, _ := sdk.AddressFromHex("0xe512234aa4ef6184c52663f09612b68f040dd0c45de037d96190a071ca5525b3")
+
+	addr1_arg := builder.Input(sdk.UnresolvedInputNewPure(addr1.ToBytes()))
+	addr2_arg := builder.Input(sdk.UnresolvedInputNewPure(addr2.ToBytes()))
+
+	address_type_tag := sdk.TypeTagNewAddress()
+	balance_type_tag := sdk.TypeTagNewU64()
+
+	buf := make([]byte, 8)
+	binary.LittleEndian.PutUint64(buf, 10_000_000)
+	bal1_arg := builder.Input(sdk.UnresolvedInputNewPure(buf))
+	binary.LittleEndian.PutUint64(buf, 20_000_000)
+	bal2_arg := builder.Input(sdk.UnresolvedInputNewPure(buf))
+
+	arg1 := builder.MakeMoveVec(&address_type_tag, []*sdk.Argument{addr1_arg, addr2_arg})
+	arg2 := builder.MakeMoveVec(&balance_type_tag, []*sdk.Argument{bal1_arg, bal2_arg})
+
+	package_name, _ := sdk.AddressFromHex("0x2")
+	module_name, _ := sdk.NewIdentifier("vec_map")
+	function_name, _ := sdk.NewIdentifier("from_keys_values")
+
+	function := sdk.Function{Package: package_name,
+		Module:   module_name,
+		Function: function_name,
+		TypeArgs: []*sdk.TypeTag{address_type_tag, balance_type_tag},
+	}
+
+	builder.MoveCall(function, []*sdk.Argument{arg1, arg2})
+
+	builder.SetGasBudget(50_000_000)
+	builder.SetGasPrice(*reference_gas_price)
+	builder.SetSender(sender)
+	builder.AddGasObjects([]*sdk.UnresolvedInput{gas_coin})
+
+	txn, err := builder.Finish()
+	if err != nil {
+		log.Fatalf("Failed to create transaction: %v", err)
+	}
+
+	skipChecks := false
+	res, err := client.DryRunTx(txn, &skipChecks)
+
+	if res.Error != nil {
+		log.Fatalf("Failed to call generic Move function: %v", err)
+	}
+
+	fmt.Print("Successfully called generic Move function")
+}

bindings/kotlin/examples/GenericMoveFunction.kt

@@ -0,0 +1,98 @@
+// Copyright (c) 2025 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+import iota_sdk.Address
+import iota_sdk.Function
+import iota_sdk.GraphQlClient
+import iota_sdk.Identifier
+import iota_sdk.ObjectId
+import iota_sdk.TransactionBuilder
+import iota_sdk.TypeTag
+import iota_sdk.UnresolvedInput
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import kotlinx.coroutines.runBlocking
+
+fun main() = runBlocking {
+    try {
+        val client = GraphQlClient.newDevnet()
+
+        val sender =
+                Address.fromHex(
+                        "0x71b4b4f171b4355ff691b7c470579cf1a926f96f724e5f9a30efc4b5f75d085e"
+                )
+
+        val gasCoin =
+                client.`object`(
+                        ObjectId.fromHex(
+                                "0xa1d009e8dafe20b1cba05e08aea488aafae1f89d892c3eaef6c0994e155e441a"
+                        )
+                )
+                        ?: error("Missing gas coin")
+
+        val builder = TransactionBuilder()
+
+        val address1 =
+                builder.input(
+                        UnresolvedInput.newPure(
+                                Address.fromHex(
+                                                "0xde49ea53fbadee67d3e35a097cdbea210b659676fc680a0b0c5f11d0763d375e"
+                                        )
+                                        .toBytes()
+                        )
+                )
+        val address2 =
+                builder.input(
+                        UnresolvedInput.newPure(
+                                Address.fromHex(
+                                                "0xe512234aa4ef6184c52663f09612b68f040dd0c45de037d96190a071ca5525b3"
+                                        )
+                                        .toBytes()
+                        )
+                )
+
+        val balance1 = builder.input(UnresolvedInput.newPure(uLongToBytes(10_000_000uL)))
+        val balance2 = builder.input(UnresolvedInput.newPure(uLongToBytes(20_000_000uL)))
+
+        val addresses = builder.makeMoveVec(TypeTag.newAddress(), listOf(address1, address2))
+        val balances = builder.makeMoveVec(TypeTag.newU64(), listOf(balance1, balance2))
+
+        val package_addr = Address.fromHex("0x2")
+        val module_name = Identifier("vec_map")
+        val function_name = Identifier("from_keys_values")
+
+        val function =
+                Function(
+                        package_addr,
+                        module_name,
+                        function_name,
+                        listOf(TypeTag.newAddress(), TypeTag.newU64())
+                )
+        builder.moveCall(function, listOf(addresses, balances))
+
+        builder.setSender(sender)
+        builder.setGasBudget(50_000_000uL)
+        builder.setGasPrice(
+                client.referenceGasPrice(null) ?: error("Failed to fetch reference gas price")
+        )
+        builder.addGasObjects(listOf(UnresolvedInput.fromObject(gasCoin).withOwnedKind()))
+
+        val txn = builder.finish()
+        val res = client.dryRunTx(txn, false)
+
+        if (res.error != null) {
+            println("Failed to call generic Move function: $res.error")
+        }
+
+        println("Successfully called generic Move function!")
+    } catch (e: Exception) {
+        e.printStackTrace()
+    }
+}
+
+fun uLongToBytes(num: ULong): ByteArray {
+    return ByteBuffer.allocate(ULong.SIZE_BYTES)
+            .order(ByteOrder.LITTLE_ENDIAN)
+            .putLong(num.toLong())
+            .array()
+}

bindings/python/examples/coin_balances.py

@@ -5,6 +5,7 @@
 
 import asyncio
 
+
 async def main():
     client = GraphQlClient.new_devnet()
 

bindings/python/examples/epoch.py

@@ -13,8 +13,7 @@ async def main():
         # Get current epoch
         current_epoch = await client.epoch()
         if current_epoch is None:
-            print("Current epoch is None")
-            return
+            raise Exception("missing current epoch")
 
         print(f"Current epoch: {current_epoch.epoch_id}")
         print(f"Current epoch start time: {current_epoch.start_timestamp}")
@@ -23,8 +22,7 @@ async def main():
         previous_epoch_id = current_epoch.epoch_id - 1
         previous_epoch = await client.epoch(previous_epoch_id)
         if previous_epoch is None:
-            print("Previous epoch is None")
-            return
+            raise Exception("missing previous epoch")
 
         print(f"Previous epoch: {previous_epoch.epoch_id}")
         if previous_epoch.total_stake_rewards is not None:

bindings/python/examples/generic_move_function.py

@@ -0,0 +1,84 @@
+# Copyright (c) 2025 IOTA Stiftung
+# SPDX-License-Identifier: Apache-2.0
+
+import asyncio
+
+from lib.iota_sdk_ffi import *
+
+
+async def main():
+    client = GraphQlClient.new_devnet()
+
+    sender = Address.from_hex(
+        "0x71b4b4f171b4355ff691b7c470579cf1a926f96f724e5f9a30efc4b5f75d085e"
+    )
+    gas_coin = await client.object(
+        ObjectId.from_hex(
+            "0xa1d009e8dafe20b1cba05e08aea488aafae1f89d892c3eaef6c0994e155e441a"
+        )
+    )
+    if gas_coin is None:
+        raise Exception("missing gas coin")
+
+    builder = TransactionBuilder()
+
+    addresses = builder.make_move_vec(
+        TypeTag.new_address(),
+        [
+            builder.input(
+                UnresolvedInput.new_pure(
+                    Address.from_hex(
+                        "0xde49ea53fbadee67d3e35a097cdbea210b659676fc680a0b0c5f11d0763d375e"
+                    ).to_bytes(),
+                )
+            ),
+            builder.input(
+                UnresolvedInput.new_pure(
+                    Address.from_hex(
+                        "0xe512234aa4ef6184c52663f09612b68f040dd0c45de037d96190a071ca5525b3"
+                    ).to_bytes()
+                )
+            ),
+        ],
+    )
+    balances = builder.make_move_vec(
+        TypeTag.new_u64(),
+        [
+            builder.input(
+                UnresolvedInput.new_pure(
+                    (10_000_000).to_bytes(8, "little", signed=False)
+                )
+            ),
+            builder.input(
+                UnresolvedInput.new_pure(
+                    (20_000_000).to_bytes(8, "little", signed=False)
+                )
+            ),
+        ],
+    )
+
+    builder.move_call(
+        Function(
+            package=Address.from_hex("0x2"),
+            module=Identifier("vec_map"),
+            function=Identifier("from_keys_values"),
+            type_args=[TypeTag.new_address(), TypeTag.new_u64()],
+        ),
+        [addresses, balances],
+    )
+    builder.set_sender(sender)
+    builder.set_gas_budget(50_000_000)
+    builder.set_gas_price(await client.reference_gas_price())
+    builder.add_gas_objects([UnresolvedInput.from_object(gas_coin).with_owned_kind()])
+
+    txn = builder.finish()
+    res = await client.dry_run_tx(txn, False)
+
+    if res.error is not None:
+        raise Exception(f"Failed to call generic Move function: {res.error}")
+
+    print("Successfully called generic Move function!")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

bindings/python/examples/get_object.py

@@ -15,7 +15,7 @@ async def main():
 
     obj = await client.object(object_id)
     if obj is None:
-        return
+        raise Exception("missing object")
 
     print("Object ID:", obj.object_id().to_hex())
     print("Version:", obj.version())

bindings/python/examples/move_functions.py

@@ -15,8 +15,7 @@ async def main():
 
     package = await client.package(package_address)
     if package is None:
-        print("no package found")
-        return
+        raise Exception("missing package")
 
     for module_id in package.modules():
         module = await client.normalized_move_module(

bindings/python/examples/owned_objects.py

@@ -4,15 +4,15 @@
 from lib.iota_sdk_ffi import *
 import asyncio
 
+
 async def main():
     client = GraphQlClient.new_devnet()
     address = Address.from_hex("0x0")
-    objects_page = await client.objects(
-        ObjectFilter(owner=address)
-    )
+    objects_page = await client.objects(ObjectFilter(owner=address))
     print(f"Owned objects({len(objects_page.data)}):")
     for obj in objects_page.data:
         print(obj.object_id().to_hex())
 
+
 if __name__ == "__main__":
     asyncio.run(main())

bindings/python/examples/pagination.py

@@ -2,11 +2,20 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import asyncio
-from lib.iota_sdk_ffi import Address, Direction, GraphQlClient, ObjectFilter, PaginationFilter
+from lib.iota_sdk_ffi import (
+    Address,
+    Direction,
+    GraphQlClient,
+    ObjectFilter,
+    PaginationFilter,
+)
+
 
 async def main():
     client = GraphQlClient.new_devnet()
-    address = Address.from_hex("0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c")
+    address = Address.from_hex(
+        "0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c"
+    )
 
     all_objects = []
     next_cursor = None
@@ -15,7 +24,7 @@ async def main():
         page = await client.objects(
             ObjectFilter(owner=address),
             # Limit to 1 to demonstrate pagination
-            PaginationFilter(direction=Direction.FORWARD, cursor=next_cursor, limit=1)
+            PaginationFilter(direction=Direction.FORWARD, cursor=next_cursor, limit=1),
         )
         all_objects.extend(page.data)
         if page.page_info.has_next_page:
@@ -26,5 +35,6 @@ async def main():
     for obj_id in all_objects:
         print(obj_id.object_id().to_hex())
 
+
 if __name__ == "__main__":
     asyncio.run(main())