Merge pull request #60 from moviepass/fix/missing-receiving-object-argument

Fix/missing receiving object argument

Author: MarcoDotIO

Sources/SuiKit/Types/Enums/Sui/Inputs/ObjectArg.swift

@@ -34,6 +34,8 @@ public enum ObjectArg: KeyProtocol {
 
     /// Represents a shared object argument.
     case shared(SharedObjectArg)
+    
+    case receiving(ReceivingObject)
 
     /// A static function to create an `ObjectArg` instance from a JSON object.
     ///
@@ -46,6 +48,8 @@ public enum ObjectArg: KeyProtocol {
         case "sharedObject":
             guard let shared = SharedObjectArg(input: input) else { return nil }
             return .shared(shared)
+        case "receiving":
+            return .receiving(ReceivingObject(input: input))
         default:
             return nil
         }
@@ -63,6 +67,9 @@ public enum ObjectArg: KeyProtocol {
         case .shared(let sharedArg):
             try Serializer.u8(serializer, UInt8(1))
             try Serializer._struct(serializer, value: sharedArg)
+        case .receiving(let receiving):
+            try Serializer.u8(serializer, UInt8(2))
+            try Serializer._struct(serializer, value: receiving)
         }
     }
 
@@ -83,6 +90,11 @@ public enum ObjectArg: KeyProtocol {
             return ObjectArg.shared(
                 try Deserializer._struct(deserializer)
             )
+        case 2:
+            return ObjectArg.receiving(
+                try Deserializer._struct(deserializer)
+            )
+
         default:
             throw SuiError.customError(message: "Unable to Deserialize")
         }

Sources/SuiKit/Types/Structs/Builders/Transactions/Inputs/Arguments/Objects/ReceivingObject.swift

@@ -0,0 +1,58 @@
+//
+//  ReceivingObject.swift
+//  SuiKit
+//
+//  Copyright (c) 2024-2025 OpenDive
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+import Foundation
+import SwiftyJSON
+
+/// A structure representing a reference to an object that is either immutable or owned.
+/// Conforming to `KeyProtocol` makes this struct usable wherever object keys are needed.
+public struct ReceivingObject: KeyProtocol {
+    /// A reference to a SuiObject.
+    public var ref: SuiObjectRef
+
+    /// Initializes a new instance of `ReceivingObject` with the provided `SuiObjectRef`.
+    ///
+    /// - Parameter ref: A reference to a `SuiObject`.
+    public init(ref: SuiObjectRef) {
+        self.ref = ref
+    }
+
+    /// Initializes a new instance of `ReceivingObject` with the provided JSON object.
+    ///
+    /// - Parameter input: A JSON object containing the data needed to initialize the `SuiObjectRef`.
+    public init(input: JSON) {
+        self.ref = SuiObjectRef(input: input)
+    }
+
+    public func serialize(_ serializer: Serializer) throws {
+        try Serializer._struct(serializer, value: self.ref)
+    }
+
+    public static func deserialize(from deserializer: Deserializer) throws -> ReceivingObject {
+        return ReceivingObject(
+            ref: try Deserializer._struct(deserializer)
+        )
+    }
+}

Sources/SuiKit/Types/Structs/Builders/Transactions/Inputs/Inputs.swift

@@ -60,6 +60,22 @@ public struct Inputs {
         )
         return .immOrOwned(immOrOwned)
     }
+    
+    /// Creates an `ObjectArg` of type `.receiving` from the provided `SuiObjectRef`.
+    ///
+    /// - Parameter suiObjectRef: The `SuiObjectRef` used to initialize the `ObjectArg`.
+    /// - Throws: If unable to normalize the SUI address contained in `suiObjectRef`.
+    /// - Returns: An `ObjectArg` object initialized with the `.receiving` variant.
+    public static func receivingRef(suiObjectRef: SuiObjectRef) throws -> ObjectArg {
+        let receiving = ReceivingObject(
+            ref: SuiObjectRef(
+                objectId: try normalizeSuiAddress(value: suiObjectRef.objectId),
+                version: suiObjectRef.version,
+                digest: suiObjectRef.digest
+            )
+        )
+        return .receiving(receiving)
+    }
 
     /// Creates an `ObjectArg` of type `.shared` from the provided `SharedObjectRef`.
     ///
@@ -100,6 +116,10 @@ public struct Inputs {
         if case .shared(let shared) = arg.object {
             return try normalizeSuiAddress(value: shared.objectId)
         }
+        
+        if case .receiving(let receiving) = arg.object {
+            return try normalizeSuiAddress(value: receiving.ref.objectId)
+        }
 
         throw SuiError.notImplemented
     }
@@ -115,6 +135,8 @@ public struct Inputs {
             return try normalizeSuiAddress(value: immOwned.ref.objectId)
         case .shared(let shared):
             return try normalizeSuiAddress(value: shared.objectId)
+        case .receiving(let receiving):
+            return try normalizeSuiAddress(value: receiving.ref.objectId)
         }
     }
 

Sources/SuiKit/Types/Structs/Builders/Transactions/TransactionBlock/TransactionBlock.swift

@@ -753,15 +753,34 @@ public class TransactionBlock {
                 // Update the input value in the objectsToResolve array based on the initial shared version or object reference
                 guard let initialSharedVersion = object.getSharedObjectInitialVersion() else {
                     guard let objRef = object.getObjectReference() else { continue }
-                    objectToResolve.input.value = .callArg(
-                        Input(
-                            type: .object(
-                                .immOrOwned(
-                                    ImmOrOwned(ref: objRef)
+                    guard let objectData = object.data else { continue }
+                    
+                    let isReceiving = try
+                    objectToResolve.normalizedType?.extractStructTag()?.address.hex() == Inputs.normalizeSuiAddress(value: "0x2") &&
+                    objectToResolve.normalizedType?.extractStructTag()?.module == "transfer" &&
+                    objectToResolve.normalizedType?.extractStructTag()?.name == "Receiving"
+                    
+                    if(isReceiving) {
+                        objectToResolve.input.value = .callArg(
+                            Input(
+                                type: .object(
+                                    .receiving(
+                                        ReceivingObject(ref: objRef)
+                                    )
                                 )
                             )
                         )
-                    )
+                    } else {
+                        objectToResolve.input.value = .callArg(
+                            Input(
+                                type: .object(
+                                    .immOrOwned(
+                                        ImmOrOwned(ref: objRef)
+                                    )
+                                )
+                            )
+                        )
+                    }
                     if resolvedObjects.count > Int(objectToResolve.input.index) {
                         resolvedObjects[Int(objectToResolve.input.index)] = objectToResolve
                     } else {