Fix Vector<Option<T>> simple args: auto-wrap BCS values in MoveOption

When BCS-encoded values (e.g. AccountAddress.ONE) are passed as elements
of vector<Option<T>>, they are now automatically wrapped in MoveOption
instead of throwing 'Type mismatch for argument N, expected MoveOption'.

The fix detects when a BCS-encoded argument is provided for an Option<T>
parameter but is not already a MoveOption, and wraps it after validating
it matches the Option's inner type.

Also adds explicit return type annotation to checkOrConvertArgument to
fix TypeScript DTS build error from the new recursive call pattern.

Co-authored-by: Greg Nazario <greg@gnazar.io>

Author: cursoragent

CHANGELOG.md

@@ -6,6 +6,7 @@ All notable changes to the Aptos TypeScript SDK will be captured in this file. T
 
 ## Fixed
 
+- Fix simple function arguments for `Vector<Option<T>>` types: BCS-encoded values (e.g. `AccountAddress.ONE`) passed as elements of `vector<Option<address>>` are now automatically wrapped in `MoveOption` instead of throwing a type mismatch error
 - Resolve moderate security advisories in `confidential-assets` dev tooling by pinning transitive `file-type` and `yauzl` (via `@swc/cli` → `@xhmikosr/downloader`) to patched releases
 - Remove hardcoded `maxGasAmount: 2000` from e2e tests (Account Derivation APIs, WebAuthn submission) that caused `MAX_GAS_UNITS_BELOW_MIN_TRANSACTION_GAS_UNITS` failures after the on-chain minimum gas increase
 - Add troubleshooting section to CONTRIBUTING.md for `ERR_WORKER_OUT_OF_MEMORY` build failures on low-RAM systems

src/transactions/transactionBuilder/remoteAbi.ts

@@ -347,23 +347,19 @@ export function checkOrConvertArgument(
   genericTypeParams: Array<TypeTag>,
   moduleAbi?: MoveModule,
   options?: { allowUnknownStructs?: boolean },
-) {
+): EntryFunctionArgumentTypes {
   // If the argument is bcs encoded, we can just use it directly
   if (isEncodedEntryFunctionArgument(arg)) {
-    // Ensure the type matches the ABI
+    // If the expected type is Option but the arg is not already a MoveOption,
+    // wrap it after validating it matches the Option's inner type.
+    // This handles cases like Vector<Option<address>> where elements may be
+    // passed as AccountAddress instead of MoveOption<AccountAddress>.
+    if (param.isStruct() && param.isOption() && !(arg instanceof MoveOption)) {
+      return new MoveOption(
+        checkOrConvertArgument(arg, param.value.typeArgs[0], position, genericTypeParams, moduleAbi, options),
+      );
+    }
 
-    /**
-     * Checks the type of the provided argument against the expected type.
-     * This function helps validate that the argument conforms to the specified type requirements.
-     *
-     * @param typeArgs - The expected type arguments.
-     * @param arg - The argument to be checked.
-     * @param position - The position of the argument in the context of the check.
-     * @param moduleAbi - The ABI of the module containing the function, used for type checking.
-     *                    This will typically have information about structs, enums, and other types.
-     * @group Implementation
-     * @category Transactions
-     */
     checkType(param, arg, position);
     return arg;
   }

tests/unit/remoteAbi.test.ts

@@ -266,20 +266,83 @@ describe("Remote ABI", () => {
         new MoveString("Hello"),
       );
 
-      // You cannot provide `new U8(0)` without MoveOption
+      // BCS-encoded values are auto-wrapped in MoveOption when the expected type is Option
       expect(
         checkOrConvertArgument(new MoveOption(new U8(255)), parseTypeTag("0x1::option::Option<u8>"), 0, []),
       ).toEqual(new MoveOption(new U8(255)));
       expect(checkOrConvertArgument(new MoveOption<U8>(), parseTypeTag("0x1::option::Option<u8>"), 0, [])).toEqual(
         new MoveOption<U8>(),
       );
+      expect(checkOrConvertArgument(new U8(255), parseTypeTag("0x1::option::Option<u8>"), 0, [])).toEqual(
+        new MoveOption(new U8(255)),
+      );
+      expect(checkOrConvertArgument(AccountAddress.ONE, parseTypeTag("0x1::option::Option<address>"), 0, [])).toEqual(
+        new MoveOption(AccountAddress.ONE),
+      );
 
       // Objects are account addresses, and it doesn't matter about the type used
       expect(
         checkOrConvertArgument(AccountAddress.ONE, parseTypeTag("0x1::object::Object<0x1::string::String>"), 0, []),
       ).toEqual(AccountAddress.ONE);
     });
 
+    it("should parse vector<Option<T>> arguments", () => {
+      // vector<Option<address>> with BCS-encoded AccountAddress elements
+      expect(
+        checkOrConvertArgument([AccountAddress.ONE], parseTypeTag("vector<0x1::option::Option<address>>"), 0, []),
+      ).toEqual(new MoveVector([new MoveOption(AccountAddress.ONE)]));
+
+      // vector<Option<address>> with string elements
+      expect(checkOrConvertArgument(["0x1"], parseTypeTag("vector<0x1::option::Option<address>>"), 0, [])).toEqual(
+        new MoveVector([new MoveOption(AccountAddress.ONE)]),
+      );
+
+      // vector<Option<address>> with null elements (empty options)
+      expect(checkOrConvertArgument([null], parseTypeTag("vector<0x1::option::Option<address>>"), 0, [])).toEqual(
+        new MoveVector([new MoveOption<AccountAddress>(null)]),
+      );
+
+      expect(checkOrConvertArgument([undefined], parseTypeTag("vector<0x1::option::Option<address>>"), 0, [])).toEqual(
+        new MoveVector([new MoveOption<AccountAddress>(null)]),
+      );
+
+      // vector<Option<address>> with mixed present and null values
+      expect(
+        checkOrConvertArgument(
+          [AccountAddress.ONE, null, "0x2"],
+          parseTypeTag("vector<0x1::option::Option<address>>"),
+          0,
+          [],
+        ),
+      ).toEqual(
+        new MoveVector([
+          new MoveOption(AccountAddress.ONE),
+          new MoveOption<AccountAddress>(null),
+          new MoveOption(AccountAddress.TWO),
+        ]),
+      );
+
+      // vector<Option<u8>> with number elements
+      expect(checkOrConvertArgument([1, 2, 3], parseTypeTag("vector<0x1::option::Option<u8>>"), 0, [])).toEqual(
+        new MoveVector([new MoveOption(new U8(1)), new MoveOption(new U8(2)), new MoveOption(new U8(3))]),
+      );
+
+      // vector<Option<u64>> with mixed values
+      expect(checkOrConvertArgument([100n, null], parseTypeTag("vector<0x1::option::Option<u64>>"), 0, [])).toEqual(
+        new MoveVector([new MoveOption(new U64(100n)), new MoveOption<U64>(null)]),
+      );
+
+      // vector<Option<u8>> with BCS-encoded elements
+      expect(checkOrConvertArgument([new U8(42)], parseTypeTag("vector<0x1::option::Option<u8>>"), 0, [])).toEqual(
+        new MoveVector([new MoveOption(new U8(42))]),
+      );
+
+      // vector<Option<u8>> with already-wrapped MoveOption elements
+      expect(
+        checkOrConvertArgument([new MoveOption(new U8(42))], parseTypeTag("vector<0x1::option::Option<u8>>"), 0, []),
+      ).toEqual(new MoveVector([new MoveOption(new U8(42))]));
+    });
+
     it("should allow mixed arguments", () => {
       expect(checkOrConvertArgument([AccountAddress.ONE, "0x2"], parseTypeTag("vector<address>"), 0, [])).toEqual(
         new MoveVector<AccountAddress>([AccountAddress.ONE, AccountAddress.TWO]),