[sdk] Add support for public struct/enum transaction arguments

Implement complete support for passing public copy structs and enums
as transaction arguments in JSON format, mirroring functionality in
the Rust CLI (aptos-core#18591).

Features:
- Automatic type inference from function ABI
- Nested structs/enums support (up to 7 levels deep)
- Generic type parameter substitution (T0, T1, etc.)
- Support for all Move primitive types (bool, u8-u256, i8-i256, address)
- Special framework types (String, Object<T>, Option<T>)
- Option<T> dual format support (vector and enum formats)
- Module ABI caching for performance
- Comprehensive validation and error messages

Implementation:
- MoveStructArgument and MoveEnumArgument BCS-serializable classes
- StructEnumArgumentParser with full encoding logic:
  * Fetches module ABI from REST API for struct/enum definitions
  * Encodes struct fields in declaration order
  * Encodes enum variants with ULEB128 indices
  * Recursive encoding for nested types
  * Generic type parameter substitution with bounds checking
- Integration into transaction builder:
  * Made argument conversion functions async (convertArgument, parseArg)
  * Added struct/enum detection logic in parseArg
  * Updated transaction builder to handle async conversions
- Complete type support:
  * All primitives (bool, u8-u256, i8-i256, address)
  * Vectors with recursive element encoding
  * Special framework types (String, Object<T>, Option<T>)

Testing:
- 70+ comprehensive unit tests with mocked module ABIs
- Tests cover: struct/enum encoding, generics, nested types, depth limits,
  error cases, Option formats, framework types, caching

Documentation:
- JSDoc with 5 usage examples in StructEnumArgumentParser class
- README section with 6 practical examples
- CHANGELOG entry with breaking changes and feature list
- Complete design document (STRUCT_ENUM_SUPPORT.md)

Breaking Changes:
- Argument conversion functions are now async to support fetching module ABIs
- Impact is minimal since top-level APIs like generateTransactionPayload
  were already async

Files:
- src/transactions/transactionBuilder/structEnumParser.ts: Complete parser implementation
- src/transactions/transactionBuilder/remoteAbi.ts: Async conversion with struct/enum support
- src/transactions/transactionBuilder/transactionBuilder.ts: Async transaction building
- src/transactions/types.ts: Added MoveStructArgument and MoveEnumArgument to type system
- src/internal/digitalAsset.ts: Async property value encoding
- tests/unit/structEnumParser.test.ts: Comprehensive test suite (70+ tests)
- tests/e2e/transaction/transactionArguments.test.ts: Updated for async
- tests/unit/remoteAbi.test.ts: Updated for async
- README.md: Usage examples section
- CHANGELOG.md: Breaking changes and features
- STRUCT_ENUM_SUPPORT.md: Complete design and status document

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: rahxephon89

CHANGELOG.md

@@ -4,12 +4,25 @@ All notable changes to the Aptos TypeScript SDK will be captured in this file. T
 
 # Unreleased
 
+## Breaking Changes
+
+- [Transactions] Argument conversion functions (`convertArgument`, `checkOrConvertArgument`, `parseArg`) are now async to support fetching module ABIs for struct/enum argument encoding. This change has minimal impact since top-level transaction building functions (`generateTransactionPayload`, etc.) were already async.
+
 ## Added
 
 - Add JWK caching for keyless authentication with 5-minute TTL to improve performance
 - Add `clearMemoizeCache()` utility function for clearing the memoization cache
 - Add Bun runtime detection with `isBun()` utility function
 - Add warning at `AptosConfig` construction time when running in Bun without explicitly disabling HTTP/2 (Bun does not fully support HTTP/2, which is enabled by default)
+- [Transactions] Add support for public copy structs and enums as transaction arguments via `MoveStructArgument`, `MoveEnumArgument`, and `StructEnumArgumentParser` classes
+  - Automatic type inference from function ABI
+  - Nested structs/enums support (up to 7 levels deep)
+  - Generic type parameter substitution (T0, T1, etc.)
+  - Support for all Move primitive types (bool, u8-u256, i8-i256, address)
+  - Special framework types (String, Object<T>, Option<T>)
+  - Option<T> dual format support (vector and enum formats)
+  - Module ABI caching for performance
+  - Comprehensive validation and error messages
 
 ## Changed
 

README.md

@@ -222,6 +222,92 @@ async function example() {
 example();
 ```
 
+### Using Struct and Enum Arguments
+
+---
+
+The SDK supports passing public copy structs and enums as transaction arguments in natural JSON format:
+
+```ts
+// Example 1: Simple struct argument
+const transaction = await aptos.transaction.build.simple({
+  sender: alice.accountAddress,
+  data: {
+    function: "0x1::shapes::draw_point",
+    functionArguments: [
+      { x: "10", y: "20" }  // Point struct
+    ],
+  },
+});
+
+// Example 2: Nested structs
+const transaction = await aptos.transaction.build.simple({
+  sender: alice.accountAddress,
+  data: {
+    function: "0x1::shapes::draw_line",
+    functionArguments: [
+      {
+        start: { x: "0", y: "0" },
+        end: { x: "10", y: "10" }
+      }  // Line struct with nested Point structs
+    ],
+  },
+});
+
+// Example 3: Enum variants
+const transaction = await aptos.transaction.build.simple({
+  sender: alice.accountAddress,
+  data: {
+    function: "0x1::game::set_color",
+    functionArguments: [
+      { Red: {} }  // Color enum, Red variant (no fields)
+    ],
+  },
+});
+
+// Example 4: Enum with fields
+const transaction = await aptos.transaction.build.simple({
+  sender: alice.accountAddress,
+  data: {
+    function: "0x1::game::create_player",
+    functionArguments: [
+      { Premium: { "0": "100" } }  // AccountType enum, Premium variant with u64 field
+    ],
+  },
+});
+
+// Example 5: Generic structs
+const transaction = await aptos.transaction.build.simple({
+  sender: alice.accountAddress,
+  data: {
+    function: "0x1::container::store",
+    functionArguments: [
+      { value: "42" }  // Box<u64> struct - type parameter automatically substituted
+    ],
+  },
+});
+
+// Example 6: Option type (dual format support)
+// Vector format (backward compatible):
+functionArguments: [[]];      // None
+functionArguments: [[42]];    // Some(42)
+
+// Enum format (new standard):
+functionArguments: [{ None: {} }];
+functionArguments: [{ Some: { "0": "42" } }];
+```
+
+**Features:**
+- Automatic type inference from function ABI
+- Support for nested structs/enums (up to 7 levels deep)
+- Generic type parameter substitution (T0, T1, etc.)
+- All Move primitive types (bool, u8-u256, i8-i256, address)
+- Special framework types (String, Object<T>, Option<T>)
+- Module ABI caching for performance
+
+**Breaking Change Note:**
+Argument conversion functions are now async to support fetching module ABIs. This is a low-impact change since top-level transaction building functions were already async.
+
 ## Troubleshooting
 
 If you see an import error when you do this: