Add Test with TS SDK (same input, same output)

CHANGELOG.md

@@ -5,6 +5,8 @@ adheres to the format set out by [Keep a Changelog](https://keepachangelog.com/e
 
 # Unreleased
 - Refactor address internal packages to be more clear
+- [`Feature`] Add simple string input support for Option types in ConvertToOption function. Now supports direct string inputs like "1" for Some(1), "true" for Some(true), etc.
+- [`Refactor`] Remove unused convertCompatibilitySerializedType function to simplify codebase
 
 # v1.10.0 (6/20/2025)
 - [`Feature`] Add orderless transaction support

typeConversion.go

@@ -1,7 +1,6 @@
 package aptos
 
 import (
-	"encoding/hex"
 	"errors"
 	"fmt"
 	"math/big"
@@ -524,92 +523,11 @@ func ConvertArg(typeArg TypeTag, arg any, generics []TypeTag, options ...any) ([
 	return nil, errors.New("failed to convert type argument")
 }
 
-func convertCompatibilitySerializedType(typeParam TypeTag, arg bcs.Deserializer, generics []TypeTag) ([]byte, error) {
-	switch innerType := typeParam.Value.(type) {
-	case *U8Tag:
-		return bcs.SerializeU8(arg.U8())
-	case *U16Tag:
-		return bcs.SerializeU16(arg.U16())
-	case *U32Tag:
-		return bcs.SerializeU32(arg.U32())
-	case *U64Tag:
-		return bcs.SerializeU64(arg.U64())
-	case *U128Tag:
-		return bcs.SerializeU128(arg.U128())
-	case *U256Tag:
-		return bcs.SerializeU256(arg.U256())
-	case *BoolTag:
-		return bcs.SerializeBool(arg.Bool())
-	case *AddressTag:
-		return bcs.SerializeBytes(arg.ReadFixedBytes(32))
-	case *SignerTag:
-		return nil, errors.New("signer is not supported")
-	case *GenericTag:
-		genericNum := innerType.Num
-		if genericNum >= uint64(len(generics)) {
-			return nil, errors.New("generic number out of bounds")
-		}
-		genericType := generics[genericNum]
-		return convertCompatibilitySerializedType(genericType, arg, generics)
-	case *ReferenceTag:
-		return convertCompatibilitySerializedType(innerType.TypeParam, arg, generics)
-	case *VectorTag:
-		length := arg.Uleb128()
-		buffer, err := bcs.SerializeUleb128(length)
-		if err != nil {
-			return nil, err
-		}
-		for range int(length) {
-			b, err := convertCompatibilitySerializedType(innerType.TypeParam, arg, generics)
-			if err != nil {
-				return nil, err
-			}
-			buffer = append(buffer, b...)
-		}
-		return buffer, nil
-	case *StructTag:
-		return convertCompatibilitySerializedType(typeParam, arg, generics)
-	default:
-		return nil, errors.New("unknown type")
-	}
-}
-
 func ConvertToOption(typeParam TypeTag, arg any, generics []TypeTag, options ...any) ([]byte, error) {
-	compatibilityMode := false
-	for _, option := range options {
-		if compatMode, ok := option.(CompatibilityMode); ok {
-			compatibilityMode = bool(compatMode)
-		}
-	}
-
 	if arg == nil {
 		return bcs.SerializeU8(0)
 	}
 
-	if compatibilityMode {
-		if typedArg, ok := arg.(string); ok {
-			if len(typedArg) >= 2 && typedArg[:2] == "0x" {
-				typedArg = typedArg[2:]
-			}
-			bytes, err := hex.DecodeString(typedArg)
-			if err != nil {
-				return nil, err
-			}
-			des := bcs.NewDeserializer(bytes)
-			length := des.Uleb128()
-			if length == 0 {
-				return bcs.SerializeU8(0)
-			} else {
-				b := []byte{1}
-				buffer, err := convertCompatibilitySerializedType(typeParam, *des, generics)
-				if err != nil {
-					return nil, err
-				}
-				return append(b, buffer...), nil
-			}
-		}
-	}
-
 	b := []byte{1}
 	buffer, err := ConvertArg(typeParam, arg, generics, options...)
 	if err != nil {