feat: add gas_sponsor example

Author: Thoralf-M

bindings/go/examples/gas_sponsor/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 main() {
+	client := sdk.GraphQlClientNewDevnet()
+
+	sender, _ := sdk.AddressFromHex("0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900")
+	sponsor, _ := sdk.AddressFromHex("0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c")
+
+	builder := sdk.TransactionBuilderInit(sender, client)
+
+	packageAddr, _ := sdk.AddressFromHex("0x1")
+	moduleName, _ := sdk.NewIdentifier("u8")
+	functionName, _ := sdk.NewIdentifier("max")
+
+	builder.MoveCall(
+		packageAddr,
+		moduleName,
+		functionName,
+		[]*sdk.PtbArgument{sdk.PtbArgumentU8(0), sdk.PtbArgumentU8(1)},
+		nil,
+		nil,
+	)
+
+	gasObjId, _ := sdk.ObjectIdFromHex("0x0b0270ee9d27da0db09651e5f7338dfa32c7ee6441ccefa1f6e305735bcfc7ab")
+	builder.Gas(gasObjId).Sponsor(sponsor)
+
+	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 send gas sponsor tx: %v", err)
+	}
+
+	if res.Error != nil {
+		log.Fatalf("Failed to send gas sponsor tx: %v", *res.Error)
+	}
+
+	log.Print("Gas sponsor tx dry run was successful!")
+}

bindings/kotlin/examples/GasSponsor.kt

@@ -0,0 +1,54 @@
+// 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(
+                                "0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900"
+                        )
+                val sponsor =
+                        Address.fromHex(
+                                "0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c"
+                        )
+
+                val builder = TransactionBuilder.init(sender, client)
+
+                val packageAddr = Address.fromHex("0x1")
+                val moduleName = Identifier("u8")
+                val functionName = Identifier("max")
+
+                builder.moveCall(
+                        packageAddr,
+                        moduleName,
+                        functionName,
+                        listOf(PtbArgument.u8(0u), PtbArgument.u8(1u)),
+                )
+
+                val gasObjId =
+                        ObjectId.fromHex(
+                                "0x0b0270ee9d27da0db09651e5f7338dfa32c7ee6441ccefa1f6e305735bcfc7ab"
+                        )
+                builder.gas(gasObjId).sponsor(sponsor)
+
+                val txn = builder.finish()
+
+                println("Signing Digest: ${hexEncode(txn.signingDigest())}")
+                println("Txn Bytes: ${base64Encode(txn.bcsSerialize())}")
+
+                val res = client.dryRunTx(txn, false)
+
+                if (res.error != null) {
+                        throw Exception("Failed to send gas sponsor tx: ${res.error}")
+                }
+
+                println("Gas sponsor tx dry run was successful!")
+        } catch (e: Exception) {
+                e.printStackTrace()
+        }
+}

bindings/python/examples/gas_sponsor.py

@@ -0,0 +1,54 @@
+# 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(
+            "0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900"
+        )
+        sponsor = Address.from_hex(
+            "0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c"
+        )
+
+        builder = await TransactionBuilder.init(sender, client)
+
+        package_addr = Address.from_hex("0x1")
+        module_name = Identifier("u8")
+        function_name = Identifier("max")
+
+        builder.move_call(
+            package_addr,
+            module_name,
+            function_name,
+            [PtbArgument.u8(0), PtbArgument.u8(1)],
+        )
+
+        gas_obj_id = ObjectId.from_hex(
+            "0x0b0270ee9d27da0db09651e5f7338dfa32c7ee6441ccefa1f6e305735bcfc7ab"
+        )
+        builder.gas(gas_obj_id).sponsor(sponsor)
+
+        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, False)
+        if res.error is not None:
+            raise Exception("Failed to send gas sponsor tx:", res.error)
+
+        print("Gas sponsor tx dry run was successful!")
+
+    except Exception as e:
+        print(f"Error: {e}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

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

@@ -0,0 +1,48 @@
+// 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 sender_address =
+        Address::from_str("0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900")?;
+    let sponsor_address =
+        Address::from_str("0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c")?;
+
+    let mut builder = TransactionBuilder::new(sender_address).with_client(client.clone());
+    let tx = builder
+        .move_call(Address::ONE, "u8", "max")
+        .arguments((0u8, 1u8))
+        .gas(ObjectId::from_str(
+            "0x0b0270ee9d27da0db09651e5f7338dfa32c7ee6441ccefa1f6e305735bcfc7ab",
+        )?)
+        .sponsor(sponsor_address)
+        .to_owned()
+        .finish()
+        .await?;
+
+    println!("Signing Digest: {}", hex::encode(tx.signing_digest()));
+    println!(
+        "Tx Bytes: {}",
+        base64ct::Base64::encode_string(&bcs::to_bytes(&tx)?)
+    );
+
+    let res = client.dry_run_tx(&tx, false).await?;
+
+    if let Some(err) = res.error {
+        eyre::bail!("Failed to send gas sponsor tx: {err}");
+    }
+
+    println!("Gas sponsor tx dry run was successful!");
+
+    Ok(())
+}