@aptos-labs/ts-sdk 1.34.0 → 1.35.0

package/src/client/core.ts

@@ -15,6 +15,7 @@ import { AptosApiError } from "../errors";
  * @param options.method - The HTTP method to use for the request.
  * @param options.body - The body of the request.
  * @param options.contentType - The content type of the request.
+ * @param options.acceptType - The accept type of the request.
  * @param options.params - The query parameters to include in the request.
  * @param options.overrides - Additional overrides for the request.
  * @param options.overrides.HEADERS - Custom headers to include in the request.
@@ -57,6 +58,62 @@ export async function request<Req, Res>(options: ClientRequest<Req>, client: Cli
   });
 }
 
+/**
+ * Sends a request using the specified options and returns the response.
+ *
+ * @param options - The options for the request.
+ * @param options.url - The URL to send the request to.
+ * @param options.method - The HTTP method to use for the request.
+ * @param options.body - The body of the request.
+ * @param options.contentType - The content type of the request.
+ * @param options.acceptType - The accept type of the request.
+ * @param options.params - The query parameters to include in the request.
+ * @param options.overrides - Additional overrides for the request.
+ * @param options.overrides.HEADERS - Custom headers to include in the request.
+ * @param options.overrides.AUTH_TOKEN - The authorization token for the request.
+ * @param options.overrides.API_KEY - The API key for the request.
+ * @param options.originMethod - The origin method for the request.
+ * @param client - The client used to make the request.
+ *
+ * @returns The response from the request.
+ * @group Implementation
+ * @category Client
+ */
+export async function binaryRequest<Req>(options: ClientRequest<Req>, client: Client): Promise<ClientResponse<Buffer>> {
+  if (client.binaryProvider === undefined) {
+    throw new Error("Binary provider is not provided");
+  }
+  const { url, method, body, contentType, acceptType, params, overrides, originMethod } = options;
+  const headers: Record<string, string | AnyNumber | boolean | undefined> = {
+    ...overrides?.HEADERS,
+    "x-aptos-client": `aptos-typescript-sdk/${VERSION}`,
+    "content-type": contentType ?? MimeType.JSON,
+    accept: acceptType ?? MimeType.BCS,
+    "x-aptos-typescript-sdk-origin-method": originMethod,
+  };
+
+  if (overrides?.AUTH_TOKEN) {
+    headers.Authorization = `Bearer ${overrides?.AUTH_TOKEN}`;
+  }
+  if (overrides?.API_KEY) {
+    headers.Authorization = `Bearer ${overrides?.API_KEY}`;
+  }
+
+  /*
+   * make a call using the @aptos-labs/aptos-client package
+   * {@link https://www.npmjs.com/package/@aptos-labs/aptos-client}
+   */
+  return client.binaryProvider<Req>({
+    acceptType: MimeType.BCS,
+    url,
+    method,
+    body,
+    params,
+    headers,
+    overrides,
+  });
+}
+
 /**
  * The main function to use when making an API request, returning the response or throwing an AptosApiError on failure.
  *
@@ -118,3 +175,66 @@ export async function aptosRequest<Req extends {}, Res extends {}>(
   // comes from an indexer request (e.g. 404), we'll need to mention it appropriately
   throw new AptosApiError({ apiType, aptosRequest: aptosRequestOpts, aptosResponse });
 }
+
+/**
+ * The main function to use when making an API request, returning the response or throwing an AptosApiError on failure.
+ *
+ * @param aptosRequestOpts - Options for the Aptos request, including the URL and path.
+ * @param aptosConfig - The configuration information for the SDK client instance.
+ * @param apiType - The type of API being accessed, which determines how the response is handled.
+ * @returns The response from the API request or throws an AptosApiError if the request fails.
+ * @group Implementation
+ * @category Client
+ * @experimental
+ */
+export async function aptosBinaryRequest<Req extends {}>(
+  aptosRequestOpts: AptosRequest,
+  aptosConfig: AptosConfig,
+  apiType: AptosApiType,
+): Promise<AptosResponse<Req, Buffer>> {
+  const { url, path } = aptosRequestOpts;
+  const fullUrl = path ? `${url}/${path}` : url;
+  const clientResponse = await binaryRequest<Req>({ ...aptosRequestOpts, url: fullUrl }, aptosConfig.client);
+
+  const aptosResponse: AptosResponse<Req, Buffer> = {
+    status: clientResponse.status,
+    statusText: clientResponse.statusText ?? "No status text provided",
+    data: clientResponse.data,
+    headers: clientResponse.headers,
+    config: clientResponse.config,
+    request: clientResponse.request,
+    url: fullUrl,
+  };
+
+  // Handle case for `Unauthorized` error (i.e. API_KEY error)
+  if (aptosResponse.status === 401) {
+    throw new AptosApiError({ apiType, aptosRequest: aptosRequestOpts, aptosResponse });
+  }
+
+  // to support both fullnode and indexer responses,
+  // check if it is an indexer query, and adjust response.data
+  if (apiType === AptosApiType.INDEXER) {
+    const indexerResponse = aptosResponse.data as any;
+    // Handle Indexer general errors
+    if (indexerResponse.errors) {
+      throw new AptosApiError({
+        apiType,
+        aptosRequest: aptosRequestOpts,
+        aptosResponse,
+      });
+    }
+    aptosResponse.data = indexerResponse.data as Buffer;
+  } else if (apiType === AptosApiType.PEPPER || apiType === AptosApiType.PROVER) {
+    if (aptosResponse.status >= 400) {
+      throw new AptosApiError({ apiType, aptosRequest: aptosRequestOpts, aptosResponse });
+    }
+  }
+
+  if (aptosResponse.status >= 200 && aptosResponse.status < 300) {
+    return aptosResponse;
+  }
+
+  // We have to explicitly check for all request types, because if the error is a non-indexer error, but
+  // comes from an indexer request (e.g. 404), we'll need to mention it appropriately
+  throw new AptosApiError({ apiType, aptosRequest: aptosRequestOpts, aptosResponse });
+}

package/src/client/get.ts

@@ -1,5 +1,5 @@
 import { AptosConfig } from "../api/aptosConfig";
-import { aptosRequest } from "./core";
+import { aptosBinaryRequest, aptosRequest } from "./core";
 import { AptosResponse, AnyNumber, ClientConfig, MimeType } from "../types";
 import { AptosApiType } from "../utils/const";
 
@@ -107,6 +107,46 @@ export async function get<Req extends {}, Res extends {}>(
   );
 }
 
+/**
+ * Executes a GET request to retrieve data based on the provided options.
+ *
+ * @param options - The options for the GET request.
+ * @param options.aptosConfig - The configuration object for Aptos requests.
+ * @param options.overrides - Optional overrides for the request configuration.
+ * @param options.params - Query parameters to include in the request.
+ * @param options.contentType - The content type of the request.
+ * @param options.acceptType - The accepted response type.
+ * @param options.path - The specific path for the request.
+ * @param options.originMethod - The original method of the request.
+ * @param options.type - The type of request being made.
+ * @returns The response from the GET request.
+ * @group Implementation
+ * @category Client
+ * @experimental
+ */
+export async function getBinary<Req extends {}>(options: GetRequestOptions): Promise<AptosResponse<Req, Buffer>> {
+  const { aptosConfig, overrides, params, contentType, acceptType, path, originMethod, type } = options;
+  const url = aptosConfig.getRequestUrl(type);
+
+  return aptosBinaryRequest<Req>(
+    {
+      url,
+      method: "GET",
+      originMethod,
+      path,
+      contentType,
+      acceptType,
+      params,
+      overrides: {
+        ...aptosConfig.clientConfig,
+        ...overrides,
+      },
+    },
+    aptosConfig,
+    options.type,
+  );
+}
+
 /**
  * Retrieves data from the Aptos full node using the provided options.
  *
@@ -138,6 +178,38 @@ export async function getAptosFullNode<Req extends {}, Res extends {}>(
   });
 }
 
+/**
+ * Retrieves data from the Aptos full node using the provided options.
+ *
+ * @param options - The options for the request to the Aptos full node.
+ * @param options.aptosConfig - Configuration settings specific to the Aptos client and full node.
+ * @param options.aptosConfig.clientConfig - The client configuration settings.
+ * @param options.aptosConfig.fullnodeConfig - The full node configuration settings.
+ * @param options.overrides - Additional overrides for the request.
+ * @param options.type - The type of API request being made.
+ *
+ * @returns A promise that resolves with the response from the Aptos full node.
+ * @group Implementation
+ * @category Client
+ * @experimental
+ */
+export async function getBinaryAptosFullNode<Req extends {}>(
+  options: GetAptosRequestOptions,
+): Promise<AptosResponse<Req, Buffer>> {
+  const { aptosConfig } = options;
+
+  return getBinary<Req>({
+    ...options,
+    type: AptosApiType.FULLNODE,
+    overrides: {
+      ...aptosConfig.clientConfig,
+      ...aptosConfig.fullnodeConfig,
+      ...options.overrides,
+      HEADERS: { ...aptosConfig.clientConfig?.HEADERS, ...aptosConfig.fullnodeConfig?.HEADERS },
+    },
+  });
+}
+
 /**
  * Makes a GET request to the Aptos Pepper service to retrieve data.
  *

package/src/client/post.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { AptosConfig } from "../api/aptosConfig";
-import { aptosRequest } from "./core";
+import { aptosBinaryRequest, aptosRequest } from "./core";
 import { AptosResponse, AnyNumber, ClientConfig, MimeType } from "../types";
 import { AptosApiType } from "../utils/const";
 
@@ -115,6 +115,45 @@ export async function post<Req extends {}, Res extends {}>(
   );
 }
 
+/**
+ * Executes a POST request to the specified URL with the provided options.
+ *
+ * @param options - The options for the POST request.
+ * @param options.type - The type of the request.
+ * @param options.originMethod - The original method that initiated the request.
+ * @param options.path - The path for the request.
+ * @param options.body - The body content to be sent with the request.
+ * @param options.acceptType - The type of response expected from the server.
+ * @param options.contentType - The content type of the request body.
+ * @param options.params - Additional parameters to include in the request.
+ * @param options.aptosConfig - Configuration settings for the Aptos request.
+ * @param options.overrides - Any overrides for the default request behavior.
+ * @returns The response from the POST request.
+ * @group Implementation
+ * @category Client
+ * @experimental
+ */
+export async function postBinary<Req extends {}>(options: PostRequestOptions): Promise<AptosResponse<Req, Buffer>> {
+  const { type, originMethod, path, body, acceptType, contentType, params, aptosConfig, overrides } = options;
+  const url = aptosConfig.getRequestUrl(type);
+
+  return aptosBinaryRequest<Req>(
+    {
+      url,
+      method: "POST",
+      originMethod,
+      path,
+      body,
+      contentType,
+      acceptType,
+      params,
+      overrides,
+    },
+    aptosConfig,
+    options.type,
+  );
+}
+
 /**
  * Sends a request to the Aptos full node using the specified options.
  * This function allows you to interact with the Aptos blockchain by sending requests to the full node.
@@ -144,6 +183,36 @@ export async function postAptosFullNode<Req extends {}, Res extends {}>(
   });
 }
 
+/**
+ * Sends a request to the Aptos full node using the specified options.
+ * This function allows you to interact with the Aptos blockchain by sending requests to the full node.
+ *
+ * @param options - The options for the request.
+ * @param options.aptosConfig - Configuration settings for the Aptos client.
+ * @param options.aptosConfig.clientConfig - Client-specific configuration settings.
+ * @param options.aptosConfig.fullnodeConfig - Full node-specific configuration settings.
+ * @param options.overrides - Additional overrides for the request.
+ * @group Implementation
+ * @category Client
+ * @experimental
+ */
+export async function postBinaryAptosFullNode<Req extends {}>(
+  options: PostAptosRequestOptions,
+): Promise<AptosResponse<Req, Buffer>> {
+  const { aptosConfig } = options;
+
+  return postBinary<Req>({
+    ...options,
+    type: AptosApiType.FULLNODE,
+    overrides: {
+      ...aptosConfig.clientConfig,
+      ...aptosConfig.fullnodeConfig,
+      ...options.overrides,
+      HEADERS: { ...aptosConfig.clientConfig?.HEADERS, ...aptosConfig.fullnodeConfig?.HEADERS },
+    },
+  });
+}
+
 /**
  * Sends a request to the Aptos indexer with the specified options.
  * This function allows you to interact with the Aptos indexer and customize the request using various configurations.

package/src/core/crypto/multiEd25519.ts

@@ -5,7 +5,8 @@ import { Deserializer, Serializer } from "../../bcs";
 import { SigningScheme as AuthenticationKeyScheme } from "../../types";
 import { AuthenticationKey } from "../authenticationKey";
 import { Ed25519PublicKey, Ed25519Signature } from "./ed25519";
-import { AccountPublicKey, VerifySignatureArgs } from "./publicKey";
+import { AbstractMultiKey } from "./multiKey";
+import { VerifySignatureArgs } from "./publicKey";
 import { Signature } from "./signature";
 
 /**
@@ -19,7 +20,7 @@ import { Signature } from "./signature";
  * @group Implementation
  * @category Serialization
  */
-export class MultiEd25519PublicKey extends AccountPublicKey {
+export class MultiEd25519PublicKey extends AbstractMultiKey {
   /**
    * Maximum number of public keys supported
    * @group Implementation
@@ -69,8 +70,8 @@ export class MultiEd25519PublicKey extends AccountPublicKey {
    * @category Serialization
    */
   constructor(args: { publicKeys: Ed25519PublicKey[]; threshold: number }) {
-    super();
     const { publicKeys, threshold } = args;
+    super({ publicKeys });
 
     // Validate number of public keys
     if (publicKeys.length > MultiEd25519PublicKey.MAX_KEYS || publicKeys.length < MultiEd25519PublicKey.MIN_KEYS) {
@@ -209,6 +210,21 @@ export class MultiEd25519PublicKey extends AccountPublicKey {
   }
 
   // endregion
+
+  /**
+   * 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
+   */
+  getIndex(publicKey: Ed25519PublicKey): number {
+    return super.getIndex(publicKey);
+  }
 }
 
 /**

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/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/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 {
@@ -700,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);
   }