feat: Return ObjectChange in ExecuteTx and DryRun

In the previous JSON RPC, iota_executeTransactionBlock and dry run would return
object changes and balance changes. However, thee fields are not returned in
the current GraphQL sdk.

Author: howjmay

bindings/go/examples/execute_transaction_dry_run/main.go

@@ -0,0 +1,102 @@
+// Copyright (c) 2025 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+package main
+
+import (
+	"log"
+
+	sdk "bindings/iota_sdk_ffi"
+)
+
+// === DryRun with ObjectChange Example ===
+// This example demonstrates the ObjectChange feature using DryRun,
+// which simulates transaction execution without actual on-chain changes.
+func main() {
+
+	// Initialize client
+	client := sdk.GraphQlClientNewDevnet()
+
+	// Use actual addresses from devnet (these are examples)
+	fromAddress, _ := sdk.AddressFromHex("0x611830d3641a68f94a690dcc25d1f4b0dac948325ac18f6dd32564371735f32c")
+
+	toAddress, _ := sdk.AddressFromHex("0x0000a4984bd495d4346fa208ddff4f5d5e5ad48c21dec631ddebc99809f16900")
+
+	coinObjId, _ := sdk.ObjectIdFromHex("0xd04077fe3b6fad13b3d4ed0d535b7ca92afcac8f0f2a0e0925fb9f4f0b30c699")
+
+	gasCoinObjId, _ := sdk.ObjectIdFromHex("0x0b0270ee9d27da0db09651e5f7338dfa32c7ee6441ccefa1f6e305735bcfc7ab")
+
+	builder := sdk.TransactionBuilderInit(fromAddress, client)
+	builder.TransferObjects(toAddress, []*sdk.PtbArgument{sdk.PtbArgumentObjectId(coinObjId)})
+	builder.Gas(gasCoinObjId).GasBudget(1000000000)
+
+	dryRunResult, err := builder.DryRun(false)
+	if err.(*sdk.SdkFfiError) != nil {
+		log.Fatalf("Dry run failed: %v", err)
+	}
+
+	if dryRunResult.Error != nil {
+		log.Fatalf("Dry run returned an error: %s\n", *dryRunResult.Error)
+	}
+
+	log.Printf("Dry run succeeded!\n")
+
+	// Access transaction effects from dry run
+	if dryRunResult.Effects != nil {
+		PrintObjectChanges(*dryRunResult.Effects)
+	} else {
+		log.Println("No transaction effects available in dry run result")
+	}
+}
+
+func PrintObjectChanges(effects *sdk.TransactionEffects) {
+	log.Println("=== Object Changes (from DryRun) ===")
+
+	if !effects.IsV1() {
+		log.Println("Effects version is not V1")
+		return
+	}
+
+	effectsV1 := effects.AsV1()
+	log.Printf("Total changed objects: %d\n", len(effectsV1.ChangedObjects))
+
+	for i, change := range effectsV1.ChangedObjects {
+		log.Printf("Object #%d:\n", i+1)
+		log.Printf("  Object ID: %s\n", change.ObjectId.ToHex())
+
+		// Check creation/deletion status using IdOperation
+		switch change.IdOperation {
+		case sdk.IdOperationCreated:
+			log.Println("  Status: CREATED")
+		case sdk.IdOperationDeleted:
+			log.Println("  Status: DELETED")
+		case sdk.IdOperationNone:
+			log.Println("  Status: MODIFIED")
+		}
+
+		// Object type (if available)
+		if change.ObjectType != nil {
+			log.Printf("  Type: %s\n", *change.ObjectType)
+		} else {
+			log.Printf("  Type: %v\n", change.ObjectType)
+		}
+
+		// Input state (state before transaction)
+		switch input := change.InputState.(type) {
+		case sdk.ObjectInMissing:
+			log.Println("  Input State: Missing (new object)")
+		case sdk.ObjectInData:
+			log.Printf("  Input State: Version=%d, Owner=%s\n", input.Version, input.Owner.String())
+		}
+
+		// Output state (state after transaction)
+		switch output := change.OutputState.(type) {
+		case sdk.ObjectOutMissing:
+			log.Println("  Output State: Missing (deleted)")
+		case sdk.ObjectOutObjectWrite:
+			log.Printf("  Output State: ObjectWrite, Owner=%s\n", output.Owner.String())
+		case sdk.ObjectOutPackageWrite:
+			log.Printf("  Output State: PackageWrite, Version=%d\n", output.Version)
+		}
+	}
+}

bindings/go/iota_sdk_ffi/iota_sdk_ffi.go

@@ -24304,13 +24304,17 @@ type ChangedObject struct {
 	// This information isn't required by the protocol but is useful for
 	// providing more detailed semantics on object changes.
 	IdOperation IdOperation
+	// Optional object type information. This is not part of the BCS protocol
+	// data but can be populated from other sources when available.
+	ObjectType *string
 }
 
 func (r *ChangedObject) Destroy() {
 		FfiDestroyerObjectId{}.Destroy(r.ObjectId);
 		FfiDestroyerObjectIn{}.Destroy(r.InputState);
 		FfiDestroyerObjectOut{}.Destroy(r.OutputState);
 		FfiDestroyerIdOperation{}.Destroy(r.IdOperation);
+		FfiDestroyerOptionalString{}.Destroy(r.ObjectType);
 }
 
 type FfiConverterChangedObject struct {}
@@ -24327,6 +24331,7 @@ func (c FfiConverterChangedObject) Read(reader io.Reader) ChangedObject {
 			FfiConverterObjectInINSTANCE.Read(reader),
 			FfiConverterObjectOutINSTANCE.Read(reader),
 			FfiConverterIdOperationINSTANCE.Read(reader),
+			FfiConverterOptionalStringINSTANCE.Read(reader),
 	}
 }
 
@@ -24339,6 +24344,7 @@ func (c FfiConverterChangedObject) Write(writer io.Writer, value ChangedObject)
 		FfiConverterObjectInINSTANCE.Write(writer, value.InputState);
 		FfiConverterObjectOutINSTANCE.Write(writer, value.OutputState);
 		FfiConverterIdOperationINSTANCE.Write(writer, value.IdOperation);
+		FfiConverterOptionalStringINSTANCE.Write(writer, value.ObjectType);
 }
 
 type FfiDestroyerChangedObject struct {}

bindings/kotlin/lib/iota_sdk/iota_sdk_ffi.kt

@@ -44001,7 +44001,12 @@ data class ChangedObject (
      * This information isn't required by the protocol but is useful for
      * providing more detailed semantics on object changes.
      */
-    var `idOperation`: IdOperation
+    var `idOperation`: IdOperation, 
+    /**
+     * Optional object type information. This is not part of the BCS protocol
+     * data but can be populated from other sources when available.
+     */
+    var `objectType`: kotlin.String? = null
 ) : Disposable {
 
     @Suppress("UNNECESSARY_SAFE_CALL") // codegen is much simpler if we unconditionally emit safe calls here
@@ -44011,7 +44016,8 @@ data class ChangedObject (
         this.`objectId`,
         this.`inputState`,
         this.`outputState`,
-        this.`idOperation`
+        this.`idOperation`,
+        this.`objectType`
     )
     }
 
@@ -44028,21 +44034,24 @@ public object FfiConverterTypeChangedObject: FfiConverterRustBuffer<ChangedObjec
             FfiConverterTypeObjectIn.read(buf),
             FfiConverterTypeObjectOut.read(buf),
             FfiConverterTypeIdOperation.read(buf),
+            FfiConverterOptionalString.read(buf),
         )
     }
 
     override fun allocationSize(value: ChangedObject) = (
             FfiConverterTypeObjectId.allocationSize(value.`objectId`) +
             FfiConverterTypeObjectIn.allocationSize(value.`inputState`) +
             FfiConverterTypeObjectOut.allocationSize(value.`outputState`) +
-            FfiConverterTypeIdOperation.allocationSize(value.`idOperation`)
+            FfiConverterTypeIdOperation.allocationSize(value.`idOperation`) +
+            FfiConverterOptionalString.allocationSize(value.`objectType`)
     )
 
     override fun write(value: ChangedObject, buf: ByteBuffer) {
             FfiConverterTypeObjectId.write(value.`objectId`, buf)
             FfiConverterTypeObjectIn.write(value.`inputState`, buf)
             FfiConverterTypeObjectOut.write(value.`outputState`, buf)
             FfiConverterTypeIdOperation.write(value.`idOperation`, buf)
+            FfiConverterOptionalString.write(value.`objectType`, buf)
     }
 }
 

bindings/python/lib/iota_sdk_ffi.py

@@ -9524,14 +9524,24 @@ class ChangedObject:
     providing more detailed semantics on object changes.
     """
 
-    def __init__(self, *, object_id: "ObjectId", input_state: "ObjectIn", output_state: "ObjectOut", id_operation: "IdOperation"):
+    object_type: "typing.Optional[str]"
+    """
+    Optional object type information. This is not part of the BCS protocol
+    data but can be populated from other sources when available.
+    """
+
+    def __init__(self, *, object_id: "ObjectId", input_state: "ObjectIn", output_state: "ObjectOut", id_operation: "IdOperation", object_type: "typing.Optional[str]" = _DEFAULT):
         self.object_id = object_id
         self.input_state = input_state
         self.output_state = output_state
         self.id_operation = id_operation
+        if object_type is _DEFAULT:
+            self.object_type = None
+        else:
+            self.object_type = object_type
 
     def __str__(self):
-        return "ChangedObject(object_id={}, input_state={}, output_state={}, id_operation={})".format(self.object_id, self.input_state, self.output_state, self.id_operation)
+        return "ChangedObject(object_id={}, input_state={}, output_state={}, id_operation={}, object_type={})".format(self.object_id, self.input_state, self.output_state, self.id_operation, self.object_type)
 
     def __eq__(self, other):
         if self.object_id != other.object_id:
@@ -9542,6 +9552,8 @@ def __eq__(self, other):
             return False
         if self.id_operation != other.id_operation:
             return False
+        if self.object_type != other.object_type:
+            return False
         return True
 
 class _UniffiConverterTypeChangedObject(_UniffiConverterRustBuffer):
@@ -9552,6 +9564,7 @@ def read(buf):
             input_state=_UniffiConverterTypeObjectIn.read(buf),
             output_state=_UniffiConverterTypeObjectOut.read(buf),
             id_operation=_UniffiConverterTypeIdOperation.read(buf),
+            object_type=_UniffiConverterOptionalString.read(buf),
         )
 
     @staticmethod
@@ -9560,13 +9573,15 @@ def check_lower(value):
         _UniffiConverterTypeObjectIn.check_lower(value.input_state)
         _UniffiConverterTypeObjectOut.check_lower(value.output_state)
         _UniffiConverterTypeIdOperation.check_lower(value.id_operation)
+        _UniffiConverterOptionalString.check_lower(value.object_type)
 
     @staticmethod
     def write(value, buf):
         _UniffiConverterTypeObjectId.write(value.object_id, buf)
         _UniffiConverterTypeObjectIn.write(value.input_state, buf)
         _UniffiConverterTypeObjectOut.write(value.output_state, buf)
         _UniffiConverterTypeIdOperation.write(value.id_operation, buf)
+        _UniffiConverterOptionalString.write(value.object_type, buf)
 
 
 class CheckpointSummaryPage:

crates/iota-graphql-client/src/lib.rs

@@ -266,7 +266,7 @@ impl Client {
             .data
             .and_then(|tx| tx.dry_run_transaction_block.transaction);
 
-        let effects = txn_block
+        let mut effects = txn_block
             .as_ref()
             .and_then(|tx| tx.effects.as_ref())
             .and_then(|tx| tx.bcs.as_ref())
@@ -275,6 +275,15 @@ impl Client {
             .map(|bcs| bcs::from_bytes::<TransactionEffects>(&bcs))
             .transpose()?;
 
+        // Populate object_type field from GraphQL object_changes
+        if let Some(ref mut effects) = effects {
+            if let Some(ref txn_block_ref) = txn_block {
+                if let Some(ref effects_gql) = txn_block_ref.effects {
+                    populate_object_types(effects, &effects_gql.object_changes.nodes);
+                }
+            }
+        }
+
         // Extract transaction
         let transaction = txn_block
             .and_then(|tx| tx.bcs)
@@ -1801,6 +1810,53 @@ impl Client {
     }
 }
 
+/// Helper function to populate object_type fields in TransactionEffects
+/// from GraphQL ObjectChange data
+fn populate_object_types(
+    effects: &mut TransactionEffects,
+    object_changes: &[query_types::TransactionObjectChange],
+) {
+    use iota_types::TransactionEffects;
+    use query_types::TransactionObjectChange as ObjectChange;
+
+    // Get the changed_objects from the effects based on version
+    match effects {
+        TransactionEffects::V1(ref mut effects_v1) => {
+            // Create a map of object_id -> object_type from GraphQL data
+            let type_map: std::collections::HashMap<ObjectId, String> = object_changes
+                .iter()
+                .filter_map(|change: &ObjectChange| {
+                    // Try to get type from output_state first, then input_state
+                    let object_type = change
+                        .output_state
+                        .as_ref()
+                        .and_then(|obj| obj.as_move_object.as_ref())
+                        .and_then(|move_obj| move_obj.contents.as_ref())
+                        .map(|contents| contents.type_.repr.clone())
+                        .or_else(|| {
+                            change
+                                .input_state
+                                .as_ref()
+                                .and_then(|obj| obj.as_move_object.as_ref())
+                                .and_then(|move_obj| move_obj.contents.as_ref())
+                                .map(|contents| contents.type_.repr.clone())
+                        });
+
+                    // Convert Address to ObjectId
+                    object_type.map(|typ| (ObjectId::from(change.address), typ))
+                })
+                .collect();
+
+            // Populate the object_type field for each changed object
+            for changed_obj in &mut effects_v1.changed_objects {
+                if let Some(object_type) = type_map.get(&changed_obj.object_id) {
+                    changed_obj.object_type = Some(object_type.clone());
+                }
+            }
+        }
+    }
+}
+
 // This function is used in tests to create a new client instance for the local
 // server.
 #[cfg(test)]

crates/iota-graphql-client/src/query_types/execute_tx.rs

@@ -2,7 +2,7 @@
 // Modifications Copyright (c) 2025 IOTA Stiftung
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::query_types::{Base64, schema};
+use crate::query_types::{Base64, PageInfo, schema};
 
 #[derive(cynic::QueryFragment, Debug)]
 #[cynic(
@@ -32,4 +32,48 @@ pub struct ExecutionResult {
 #[cynic(schema = "rpc", graphql_type = "TransactionBlockEffects")]
 pub struct TransactionBlockEffects {
     pub bcs: Base64,
+    pub object_changes: ObjectChangeConnection,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(schema = "rpc", graphql_type = "ObjectChangeConnection")]
+pub struct ObjectChangeConnection {
+    pub page_info: PageInfo,
+    pub nodes: Vec<ObjectChange>,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(schema = "rpc", graphql_type = "ObjectChange")]
+pub struct ObjectChange {
+    pub address: crate::query_types::Address,
+    pub input_state: Option<Object>,
+    pub output_state: Option<Object>,
+    pub id_created: Option<bool>,
+    pub id_deleted: Option<bool>,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(schema = "rpc", graphql_type = "Object")]
+pub struct Object {
+    pub bcs: Option<Base64>,
+    pub as_move_object: Option<MoveObject>,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(schema = "rpc", graphql_type = "MoveObject")]
+pub struct MoveObject {
+    pub contents: Option<MoveValue>,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(schema = "rpc", graphql_type = "MoveValue")]
+pub struct MoveValue {
+    #[cynic(rename = "type")]
+    pub type_: MoveType,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(schema = "rpc", graphql_type = "MoveType")]
+pub struct MoveType {
+    pub repr: String,
 }