@aptos-labs/ts-sdk 1.33.2 → 1.35.0

package/src/core/crypto/multiKey.ts

@@ -23,6 +23,79 @@ function bitCount(byte: number) {
 }
 /* eslint-enable no-bitwise */
 
+export abstract class AbstractMultiKey extends AccountPublicKey {
+  publicKeys: PublicKey[];
+
+  constructor(args: { publicKeys: PublicKey[] }) {
+    super();
+    this.publicKeys = args.publicKeys;
+  }
+
+  /**
+   * Create a bitmap that holds the mapping from the original public keys
+   * to the signatures passed in
+   *
+   * @param args.bits array of the index mapping to the matching public keys
+   * @returns Uint8array bit map
+   * @group Implementation
+   * @category Serialization
+   */
+  createBitmap(args: { bits: number[] }): Uint8Array {
+    const { bits } = args;
+    // Bits are read from left to right. e.g. 0b10000000 represents the first bit is set in one byte.
+    // The decimal value of 0b10000000 is 128.
+    const firstBitInByte = 128;
+    const bitmap = new Uint8Array([0, 0, 0, 0]);
+
+    // Check if duplicates exist in bits
+    const dupCheckSet = new Set();
+
+    bits.forEach((bit: number, idx: number) => {
+      if (idx + 1 > this.publicKeys.length) {
+        throw new Error(`Signature index ${idx + 1} is out of public keys range, ${this.publicKeys.length}.`);
+      }
+
+      if (dupCheckSet.has(bit)) {
+        throw new Error(`Duplicate bit ${bit} detected.`);
+      }
+
+      dupCheckSet.add(bit);
+
+      const byteOffset = Math.floor(bit / 8);
+
+      let byte = bitmap[byteOffset];
+
+      // eslint-disable-next-line no-bitwise
+      byte |= firstBitInByte >> bit % 8;
+
+      bitmap[byteOffset] = byte;
+    });
+
+    return bitmap;
+  }
+
+  /**
+   * Get the index of the provided public key.
+   *
+   * This function retrieves the index of a specified public key within the MultiKey.
+   * If the public key does not exist, it throws an error.
+   *
+   * @param publicKey - The public key to find the index for.
+   * @returns The corresponding index of the public key, if it exists.
+   * @throws Error - If the public key is not found in the MultiKey.
+   * @group Implementation
+   * @category Serialization
+   */
+  getIndex(publicKey: PublicKey): number {
+    const index = this.publicKeys.findIndex((pk) => pk.toString() === publicKey.toString());
+
+    if (index !== -1) {
+      return index;
+    }
+    throw new Error(`Public key ${publicKey} not found in multi key set ${this.publicKeys}`);
+  }
+}
+
 /**
  * Represents a multi-key authentication scheme for accounts, allowing multiple public keys
  * to be associated with a single account. This class enforces a minimum number of valid signatures
@@ -34,7 +107,7 @@ function bitCount(byte: number) {
  * @group Implementation
  * @category Serialization
  */
-export class MultiKey extends AccountPublicKey {
+export class MultiKey extends AbstractMultiKey {
   /**
    * List of any public keys
    * @group Implementation
@@ -65,8 +138,8 @@ export class MultiKey extends AccountPublicKey {
    */
   // region Constructors
   constructor(args: { publicKeys: Array<PublicKey>; signaturesRequired: number }) {
-    super();
     const { publicKeys, signaturesRequired } = args;
+    super({ publicKeys });
 
     // Validate number of public keys is greater than signature required
     if (signaturesRequired < 1) {
@@ -156,49 +229,6 @@ export class MultiKey extends AccountPublicKey {
 
   // endregion
 
-  /**
-   * Create a bitmap that holds the mapping from the original public keys
-   * to the signatures passed in
-   *
-   * @param args.bits array of the index mapping to the matching public keys
-   * @returns Uint8array bit map
-   * @group Implementation
-   * @category Serialization
-   */
-  createBitmap(args: { bits: number[] }): Uint8Array {
-    const { bits } = args;
-    // Bits are read from left to right. e.g. 0b10000000 represents the first bit is set in one byte.
-    // The decimal value of 0b10000000 is 128.
-    const firstBitInByte = 128;
-    const bitmap = new Uint8Array([0, 0, 0, 0]);
-
-    // Check if duplicates exist in bits
-    const dupCheckSet = new Set();
-
-    bits.forEach((bit: number, idx: number) => {
-      if (idx + 1 > this.publicKeys.length) {
-        throw new Error(`Signature index ${idx + 1} is out of public keys range, ${this.publicKeys.length}.`);
-      }
-
-      if (dupCheckSet.has(bit)) {
-        throw new Error(`Duplicate bit ${bit} detected.`);
-      }
-
-      dupCheckSet.add(bit);
-
-      const byteOffset = Math.floor(bit / 8);
-
-      let byte = bitmap[byteOffset];
-
-      // eslint-disable-next-line no-bitwise
-      byte |= firstBitInByte >> bit % 8;
-
-      bitmap[byteOffset] = byte;
-    });
-
-    return bitmap;
-  }
-
   /**
    * Get the index of the provided public key.
    *
@@ -209,16 +239,10 @@ export class MultiKey extends AccountPublicKey {
    * @returns The corresponding index of the public key, if it exists.
    * @throws Error - If the public key is not found in the MultiKey.
    * @group Implementation
-   * @category Serialization
    */
   getIndex(publicKey: PublicKey): number {
     const anyPublicKey = publicKey instanceof AnyPublicKey ? publicKey : new AnyPublicKey(publicKey);
-    const index = this.publicKeys.findIndex((pk) => pk.toString() === anyPublicKey.toString());
-
-    if (index !== -1) {
-      return index;
-    }
-    throw new Error(`Public key ${publicKey} not found in MultiKey ${this.publicKeys}`);
+    return super.getIndex(anyPublicKey);
   }
 
   public static isInstance(value: PublicKey): value is MultiKey {

package/src/core/hex.ts

@@ -146,8 +146,10 @@ export class Hex {
    * @category Serialization
    */
   static fromHexInput(hexInput: HexInput): Hex {
+    if (hexInput instanceof Buffer) return new Hex(new Uint8Array(hexInput));
     if (hexInput instanceof Uint8Array) return new Hex(hexInput);
-    return Hex.fromHexString(hexInput);
+    if (typeof hexInput === "string") return Hex.fromHexString(hexInput);
+    throw new Error(`Invalid hex input type: ${typeof hexInput}`);
   }
 
   /**

package/src/internal/abstraction.ts

@@ -0,0 +1,79 @@
+import {
+  SimpleTransaction,
+  InputGenerateTransactionOptions,
+  TypeTagAddress,
+  TypeTagStruct,
+  stringStructTag,
+} from "../transactions";
+import { AccountAddressInput } from "../core";
+import { generateTransaction } from "./transactionSubmission";
+import { MoveFunctionId } from "../types";
+import { AptosConfig } from "../api/aptosConfig";
+import { getFunctionParts } from "../utils/helpers";
+
+export async function addAuthenticationFunctionTransaction(args: {
+  aptosConfig: AptosConfig;
+  sender: AccountAddressInput;
+  authenticationFunction: string;
+  options?: InputGenerateTransactionOptions;
+}): Promise<SimpleTransaction> {
+  const { aptosConfig, sender, authenticationFunction, options } = args;
+  const { moduleAddress, moduleName, functionName } = getFunctionParts(authenticationFunction as MoveFunctionId);
+  return generateTransaction({
+    aptosConfig,
+    sender,
+    data: {
+      function: "0x1::account_abstraction::add_authentication_function",
+      typeArguments: [],
+      functionArguments: [moduleAddress, moduleName, functionName],
+      abi: {
+        typeParameters: [],
+        parameters: [new TypeTagAddress(), new TypeTagStruct(stringStructTag()), new TypeTagStruct(stringStructTag())],
+      },
+    },
+    options,
+  });
+}
+
+export async function removeAuthenticationFunctionTransaction(args: {
+  aptosConfig: AptosConfig;
+  sender: AccountAddressInput;
+  authenticationFunction: string;
+  options?: InputGenerateTransactionOptions;
+}) {
+  const { aptosConfig, sender, authenticationFunction, options } = args;
+  const { moduleAddress, moduleName, functionName } = getFunctionParts(authenticationFunction as MoveFunctionId);
+  return generateTransaction({
+    aptosConfig,
+    sender,
+    data: {
+      function: "0x1::account_abstraction::remove_authentication_function",
+      typeArguments: [],
+      functionArguments: [moduleAddress, moduleName, functionName],
+      abi: {
+        typeParameters: [],
+        parameters: [new TypeTagAddress(), new TypeTagStruct(stringStructTag()), new TypeTagStruct(stringStructTag())],
+      },
+    },
+    options,
+  });
+}
+
+export async function removeDispatchableAuthenticatorTransaction(args: {
+  aptosConfig: AptosConfig;
+  sender: AccountAddressInput;
+  options?: InputGenerateTransactionOptions;
+}) {
+  const { aptosConfig, sender, options } = args;
+  return generateTransaction({
+    aptosConfig,
+    sender,
+    data: {
+      function: "0x1::account_abstraction::remove_authenticator",
+      typeArguments: [],
+      functionArguments: [],
+      abi: { typeParameters: [], parameters: [] },
+    },
+    options,
+  });
+}

package/src/internal/experimental.ts

@@ -0,0 +1,55 @@
+import { AptosConfig } from "../api/aptosConfig";
+import { generateViewFunctionPayload, InputViewFunctionData } from "../transactions";
+import { LedgerVersionArg, MimeType } from "../types";
+import { Serializer } from "../bcs";
+import { postBinaryAptosFullNode } from "../client";
+
+export async function viewBinary(args: {
+  aptosConfig: AptosConfig;
+  payload: InputViewFunctionData;
+  options?: LedgerVersionArg & { convert?: undefined };
+}): Promise<Uint8Array>;
+
+export async function viewBinary<T extends {}>(args: {
+  aptosConfig: AptosConfig;
+  payload: InputViewFunctionData;
+  options?: LedgerVersionArg & { convert?: (input: Uint8Array) => T };
+}): Promise<T>;
+
+/**
+ * Reads a binary view function, and converts into the appropriate type if a converter is provided.
+ * @experimental
+ * @param args
+ */
+export async function viewBinary<T extends {} = Uint8Array>(args: {
+  aptosConfig: AptosConfig;
+  payload: InputViewFunctionData;
+  options?: LedgerVersionArg & { convert?: (input: Uint8Array) => T };
+}): Promise<Uint8Array | T> {
+  const { aptosConfig, payload, options } = args;
+  const viewFunctionPayload = await generateViewFunctionPayload({
+    ...payload,
+    aptosConfig,
+  });
+
+  const serializer = new Serializer();
+  viewFunctionPayload.serialize(serializer);
+  const bytes = serializer.toUint8Array();
+
+  const { data } = await postBinaryAptosFullNode<Uint8Array>({
+    aptosConfig,
+    path: "view",
+    originMethod: "view",
+    contentType: MimeType.BCS_VIEW_FUNCTION,
+    acceptType: MimeType.BCS,
+    params: { ledger_version: options?.ledgerVersion },
+    body: bytes,
+  });
+
+  const array = new Uint8Array(data);
+  if (options?.convert) {
+    return options.convert(array);
+  }
+
+  return array;
+}

package/src/internal/view.ts

@@ -27,7 +27,7 @@ export async function view<T extends Array<MoveValue> = Array<MoveValue>>(args:
   viewFunctionPayload.serialize(serializer);
   const bytes = serializer.toUint8Array();
 
-  const { data } = await postAptosFullNode<Uint8Array, MoveValue[]>({
+  const { data } = await postAptosFullNode<Uint8Array, T>({
     aptosConfig,
     path: "view",
     originMethod: "view",
@@ -36,7 +36,7 @@ export async function view<T extends Array<MoveValue> = Array<MoveValue>>(args:
     body: bytes,
   });
 
-  return data as T;
+  return data;
 }
 
 export async function viewJson<T extends Array<MoveValue> = Array<MoveValue>>(args: {
@@ -45,7 +45,7 @@ export async function viewJson<T extends Array<MoveValue> = Array<MoveValue>>(ar
   options?: LedgerVersionArg;
 }): Promise<T> {
   const { aptosConfig, payload, options } = args;
-  const { data } = await postAptosFullNode<ViewFunctionJsonPayload, MoveValue[]>({
+  const { data } = await postAptosFullNode<ViewFunctionJsonPayload, T>({
     aptosConfig,
     originMethod: "viewJson",
     path: "view",
@@ -57,5 +57,5 @@ export async function viewJson<T extends Array<MoveValue> = Array<MoveValue>>(ar
     },
   });
 
-  return data as T;
+  return data;
 }

package/src/transactions/authenticator/account.ts

@@ -8,7 +8,10 @@ import { AnyPublicKey, AnySignature } from "../../core/crypto";
 import { Ed25519PublicKey, Ed25519Signature } from "../../core/crypto/ed25519";
 import { MultiEd25519PublicKey, MultiEd25519Signature } from "../../core/crypto/multiEd25519";
 import { MultiKey, MultiKeySignature } from "../../core/crypto/multiKey";
-import { AccountAuthenticatorVariant } from "../../types";
+import { AccountAuthenticatorVariant, HexInput, MoveFunctionId } from "../../types";
+import { AbstractionAuthDataVariant } from "../../types/abstraction";
+import { AccountAddress, Hex } from "../../core";
+import { getFunctionParts, isValidFunctionInfo } from "../../utils/helpers";
 
 /**
  * Represents an account authenticator that can handle multiple authentication variants.
@@ -43,6 +46,8 @@ export abstract class AccountAuthenticator extends Serializable {
         return AccountAuthenticatorMultiKey.load(deserializer);
       case AccountAuthenticatorVariant.NoAccountAuthenticator:
         return AccountAuthenticatorNoAccountAuthenticator.load(deserializer);
+      case AccountAuthenticatorVariant.Abstraction:
+        return AccountAuthenticatorAbstraction.load(deserializer);
       default:
         throw new Error(`Unknown variant index for AccountAuthenticator: ${index}`);
     }
@@ -263,3 +268,49 @@ export class AccountAuthenticatorNoAccountAuthenticator extends AccountAuthentic
     return new AccountAuthenticatorNoAccountAuthenticator();
   }
 }
+
+export class AccountAuthenticatorAbstraction extends AccountAuthenticator {
+  public readonly functionInfo: string;
+
+  public readonly signingMessageDigest: Hex;
+
+  public readonly authenticator: Hex;
+
+  constructor(functionInfo: string, signingMessageDigest: HexInput, authenticator: HexInput) {
+    super();
+    if (!isValidFunctionInfo(functionInfo)) {
+      throw new Error(`Invalid function info ${functionInfo} passed into AccountAuthenticatorAbstraction`);
+    }
+    this.functionInfo = functionInfo;
+    this.authenticator = Hex.fromHexInput(authenticator);
+    this.signingMessageDigest = Hex.fromHexInput(Hex.fromHexInput(signingMessageDigest).toUint8Array());
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(AccountAuthenticatorVariant.Abstraction);
+    const { moduleAddress, moduleName, functionName } = getFunctionParts(this.functionInfo as MoveFunctionId);
+    AccountAddress.fromString(moduleAddress).serialize(serializer);
+    serializer.serializeStr(moduleName);
+    serializer.serializeStr(functionName);
+    serializer.serializeU32AsUleb128(AbstractionAuthDataVariant.V1);
+    serializer.serializeBytes(this.signingMessageDigest.toUint8Array());
+    serializer.serializeFixedBytes(this.authenticator.toUint8Array());
+  }
+
+  static load(deserializer: Deserializer): AccountAuthenticatorAbstraction {
+    const moduleAddress = AccountAddress.deserialize(deserializer);
+    const moduleName = deserializer.deserializeStr();
+    const functionName = deserializer.deserializeStr();
+    const variant = deserializer.deserializeUleb128AsU32();
+    if (variant === AbstractionAuthDataVariant.V1) {
+      const signingMessageDigest = deserializer.deserializeBytes();
+      const authenticator = deserializer.deserializeFixedBytes(deserializer.remaining());
+      return new AccountAuthenticatorAbstraction(
+        `${moduleAddress}::${moduleName}::${functionName}`,
+        signingMessageDigest,
+        authenticator,
+      );
+    }
+    throw new Error(`Unknown variant index for AccountAuthenticatorAbstraction: ${variant}`);
+  }
+}

package/src/transactions/index.ts

@@ -7,3 +7,4 @@ export * from "./transactionBuilder";
 export * from "./typeTag";
 export * from "./typeTag/parser";
 export * from "./types";
+export * from "./scriptComposer";

package/src/transactions/scriptComposer/index.ts

@@ -0,0 +1,87 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { ScriptComposerWasm } from "@aptos-labs/script-composer-pack";
+import { AptosApiType, getFunctionParts } from "../../utils";
+import { AptosConfig } from "../../api/aptosConfig";
+import { InputBatchedFunctionData } from "../types";
+import { fetchMoveFunctionAbi, standardizeTypeTags } from "../transactionBuilder";
+import { CallArgument } from "../../types";
+import { convertCallArgument } from "../transactionBuilder/remoteAbi";
+
+/**
+ * A wrapper class around TransactionComposer, which is a WASM library compiled
+ * from aptos-core/aptos-move/script-composer.
+ * This class allows the SDK caller to build a transaction that invokes multiple Move functions
+ * and allow for arguments to be passed around.
+ * */
+export class AptosScriptComposer {
+  private config: AptosConfig;
+
+  private builder?: any;
+
+  private static transactionComposer?: any;
+
+  constructor(aptosConfig: AptosConfig) {
+    this.config = aptosConfig;
+    this.builder = undefined;
+  }
+
+  // Initializing the wasm needed for the script composer, must be called
+  // before using the composer.
+  async init() {
+    if (!AptosScriptComposer.transactionComposer) {
+      const module = await import("@aptos-labs/script-composer-pack");
+      const { TransactionComposer, initSync } = module;
+      if (!ScriptComposerWasm.isInitialized) {
+        ScriptComposerWasm.init();
+      }
+      initSync({ module: ScriptComposerWasm.wasm });
+      AptosScriptComposer.transactionComposer = TransactionComposer;
+    }
+    this.builder = AptosScriptComposer.transactionComposer.single_signer();
+  }
+
+  // Add a move function invocation to the TransactionComposer.
+  //
+  // Similar to how to create an entry function, the difference is that input arguments could
+  // either be a `CallArgument` which represents an abstract value returned from a previous Move call
+  // or the regular entry function arguments.
+  //
+  // The function would also return a list of `CallArgument` that can be passed on to future calls.
+  async addBatchedCalls(input: InputBatchedFunctionData): Promise<CallArgument[]> {
+    const { moduleAddress, moduleName, functionName } = getFunctionParts(input.function);
+    const nodeUrl = this.config.getRequestUrl(AptosApiType.FULLNODE);
+
+    // Load the calling module into the builder.
+    await this.builder.load_module(nodeUrl, `${moduleAddress}::${moduleName}`);
+
+    // Load the calling type arguments into the loader.
+    if (input.typeArguments !== undefined) {
+      await Promise.all(input.typeArguments.map((typeTag) => this.builder.load_type_tag(nodeUrl, typeTag.toString())));
+    }
+    const typeArguments = standardizeTypeTags(input.typeArguments);
+    const functionAbi = await fetchMoveFunctionAbi(moduleAddress, moduleName, functionName, this.config);
+    // Check the type argument count against the ABI
+    if (typeArguments.length !== functionAbi.typeParameters.length) {
+      throw new Error(
+        `Type argument count mismatch, expected ${functionAbi.typeParameters.length}, received ${typeArguments.length}`,
+      );
+    }
+
+    const functionArguments: CallArgument[] = input.functionArguments.map((arg, i) =>
+      convertCallArgument(arg, functionName, functionAbi, i, typeArguments),
+    );
+
+    return this.builder.add_batched_call(
+      `${moduleAddress}::${moduleName}`,
+      functionName,
+      typeArguments.map((arg) => arg.toString()),
+      functionArguments,
+    );
+  }
+
+  build(): Uint8Array {
+    return this.builder.generate_batched_calls(true);
+  }
+}

package/src/transactions/transactionBuilder/helpers.ts

@@ -10,7 +10,7 @@ import {
 } from "../types";
 import { Bool, FixedBytes, MoveOption, MoveString, MoveVector, U128, U16, U256, U32, U64, U8 } from "../../bcs";
 import { AccountAddress } from "../../core";
-import { MoveFunction, MoveFunctionId } from "../../types";
+import { MoveFunction } from "../../types";
 
 /**
  * Determines if the provided argument is of type boolean.
@@ -317,24 +317,3 @@ export function findFirstNonSignerArg(functionAbi: MoveFunction): number {
   }
   return index;
 }
-
-/**
- * Splits a function identifier into its constituent parts: module address, module name, and function name.
- * This function helps in validating and extracting details from a function identifier string.
- *
- * @param functionArg - The function identifier string in the format "moduleAddress::moduleName::functionName".
- * @returns An object containing the module address, module name, and function name.
- * @throws Error if the function identifier does not contain exactly three parts.
- * @group Implementation
- * @category Transactions
- */
-export function getFunctionParts(functionArg: MoveFunctionId) {
-  const funcNameParts = functionArg.split("::");
-  if (funcNameParts.length !== 3) {
-    throw new Error(`Invalid function ${functionArg}`);
-  }
-  const moduleAddress = funcNameParts[0];
-  const moduleName = funcNameParts[1];
-  const functionName = funcNameParts[2];
-  return { moduleAddress, moduleName, functionName };
-}

package/src/transactions/transactionBuilder/remoteAbi.ts

@@ -45,7 +45,7 @@ import {
   throwTypeMismatch,
   convertNumber,
 } from "./helpers";
-import { MoveFunction } from "../../types";
+import { CallArgument, MoveFunction } from "../../types";
 
 const TEXT_ENCODER = new TextEncoder();
 
@@ -96,6 +96,34 @@ export async function fetchFunctionAbi(
   return undefined;
 }
 
+/**
+ * Fetches a function ABI from the on-chain module ABI.  It doesn't validate whether it's a view or entry function.
+ * @param moduleAddress
+ * @param moduleName
+ * @param functionName
+ * @param aptosConfig
+ */
+export async function fetchMoveFunctionAbi(
+  moduleAddress: string,
+  moduleName: string,
+  functionName: string,
+  aptosConfig: AptosConfig,
+): Promise<FunctionABI> {
+  const functionAbi = await fetchFunctionAbi(moduleAddress, moduleName, functionName, aptosConfig);
+  if (!functionAbi) {
+    throw new Error(`Could not find function ABI for '${moduleAddress}::${moduleName}::${functionName}'`);
+  }
+  const params: TypeTag[] = [];
+  for (let i = 0; i < functionAbi.params.length; i += 1) {
+    params.push(parseTypeTag(functionAbi.params[i], { allowGenerics: true }));
+  }
+
+  return {
+    typeParameters: functionAbi.generic_type_params,
+    parameters: params,
+  };
+}
+
 /**
  * Fetches the ABI for an entry function from the specified module address.
  * This function validates if the ABI corresponds to an entry function and retrieves its parameters.
@@ -191,6 +219,32 @@ export async function fetchViewFunctionAbi(
   };
 }
 
+/**
+ * Converts a entry function argument into CallArgument, if necessary.
+ * This function checks the provided argument against the expected parameter type and converts it accordingly.
+ *
+ * @param functionName - The name of the function for which the argument is being converted.
+ * @param functionAbi - The ABI (Application Binary Interface) of the function, which defines its parameters.
+ * @param argument - The argument to be converted, which can be of various types. If the argument is already
+ *                   CallArgument returned from TransactionComposer it would be returned immediately.
+ * @param position - The index of the argument in the function's parameter list.
+ * @param genericTypeParams - An array of type tags for any generic type parameters.
+ */
+export function convertCallArgument(
+  argument: CallArgument | EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes,
+  functionName: string,
+  functionAbi: FunctionABI,
+  position: number,
+  genericTypeParams: Array<TypeTag>,
+): CallArgument {
+  if (argument instanceof CallArgument) {
+    return argument;
+  }
+  return CallArgument.newBytes(
+    convertArgument(functionName, functionAbi, argument, position, genericTypeParams).bcsToBytes(),
+  );
+}
+
 /**
  * Converts a non-BCS encoded argument into BCS encoded, if necessary.
  * This function checks the provided argument against the expected parameter type and converts it accordingly.
@@ -369,6 +423,13 @@ function parseArg(
       }
     }
 
+    if (isString(arg)) {
+      // In a web env, arguments are passing as strings
+      if (arg.startsWith("[")) {
+        return checkOrConvertArgument(JSON.parse(arg), param, position, genericTypeParams);
+      }
+    }
+
     // TODO: Support Uint16Array, Uint32Array, BigUint64Array?
 
     if (Array.isArray(arg)) {

package/src/transactions/transactionBuilder/transactionBuilder.ts

@@ -29,6 +29,7 @@ import { normalizeBundle } from "../../utils/normalizeBundle";
 import {
   AccountAuthenticator,
   AccountAuthenticatorEd25519,
+  AccountAuthenticatorMultiEd25519,
   AccountAuthenticatorMultiKey,
   AccountAuthenticatorNoAccountAuthenticator,
   AccountAuthenticatorSingleKey,
@@ -38,6 +39,7 @@ import {
   TransactionAuthenticatorEd25519,
   TransactionAuthenticatorFeePayer,
   TransactionAuthenticatorMultiAgent,
+  TransactionAuthenticatorMultiEd25519,
   TransactionAuthenticatorSingleSender,
 } from "../authenticator/transaction";
 import {
@@ -77,9 +79,10 @@ import {
 } from "../types";
 import { convertArgument, fetchEntryFunctionAbi, fetchViewFunctionAbi, standardizeTypeTags } from "./remoteAbi";
 import { memoizeAsync } from "../../utils/memoize";
-import { getFunctionParts, isScriptDataInput } from "./helpers";
+import { isScriptDataInput } from "./helpers";
 import { SimpleTransaction } from "../instances/simpleTransaction";
 import { MultiAgentTransaction } from "../instances/multiAgentTransaction";
+import { getFunctionParts } from "../../utils/helpers";
 
 /**
  * Builds a transaction payload based on the provided arguments and returns a transaction payload.
@@ -699,6 +702,11 @@ export function generateSignedTransaction(args: InputSubmitTransactionData): Uin
       senderAuthenticator.public_key,
       senderAuthenticator.signature,
     );
+  } else if (senderAuthenticator instanceof AccountAuthenticatorMultiEd25519) {
+    txnAuthenticator = new TransactionAuthenticatorMultiEd25519(
+      senderAuthenticator.public_key,
+      senderAuthenticator.signature,
+    );
   } else {
     txnAuthenticator = new TransactionAuthenticatorSingleSender(senderAuthenticator);
   }