@aptos-labs/ts-sdk 1.13.3-zeta.0 → 1.13.3

package/src/api/transaction.ts

@@ -33,8 +33,7 @@ import {
   InputGenerateTransactionOptions,
   InputGenerateTransactionPayloadData,
 } from "../transactions";
-import { AccountAddressInput, PrivateKey } from "../core";
-import { Account } from "../account";
+import { AccountAddressInput, Account, PrivateKey } from "../core";
 import { Build } from "./transactionSubmission/build";
 import { Simulate } from "./transactionSubmission/simulate";
 import { Submit } from "./transactionSubmission/submit";

package/src/api/transactionSubmission/management.ts

@@ -2,7 +2,7 @@ import EventEmitter from "eventemitter3";
 import { TransactionWorkerEvents, TransactionWorker, TransactionWorkerEventsEnum } from "../../transactions/management";
 import { InputGenerateTransactionPayloadData, InputGenerateTransactionOptions } from "../../transactions";
 import { AptosConfig } from "../aptosConfig";
-import { Account } from "../../account";
+import { Account } from "../../core";
 
 export class TransactionManagement extends EventEmitter<TransactionWorkerEvents> {
   account!: Account;

package/src/api/transactionSubmission/sign.ts

@@ -1,7 +1,7 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { Account } from "../../account";
+import { Account } from "../../core";
 import { signTransaction } from "../../internal/transactionSubmission";
 import { AccountAuthenticator, AnyRawTransaction } from "../../transactions";
 import { AptosConfig } from "../aptosConfig";

package/src/bcs/serializer.ts

@@ -316,24 +316,6 @@ export class Serializer {
       item.serialize(this);
     });
   }
-
-  serializeOption<T extends Serializable>(value?: T): void {
-    if (value === undefined) {
-      this.serializeU32AsUleb128(0);
-    } else {
-      this.serializeU32AsUleb128(1);
-      value.serialize(this);
-    }
-  }
-
-  serializeOptionStr(value?: string): void {
-    if (value === undefined) {
-      this.serializeU32AsUleb128(0);
-    } else {
-      this.serializeU32AsUleb128(1);
-      this.serializeStr(value);
-    }
-  }
 }
 
 export function ensureBoolean(value: unknown): asserts value is boolean {

package/src/client/core.ts

@@ -106,14 +106,6 @@ export async function aptosRequest<Req extends {}, Res extends {}>(
     return result;
   }
 
-  if (result.status >= 500) {
-    throw new AptosApiError(options, result, `${response.data}`);
-  }
-
-  if (aptosConfig.isPepperServiceRequest(url)) {
-    throw new AptosApiError(options, result, `${response.data}`);
-  }
-
   let errorMessage: string;
 
   if (result && result.data && "message" in result.data && "error_code" in result.data) {

package/src/client/get.ts

@@ -89,12 +89,6 @@ export async function getAptosFullNode<Req extends {}, Res extends {}>(
   });
 }
 
-export async function getAptosPepperService<Req extends {}, Res extends {}>(
-  options: GetAptosRequestOptions,
-): Promise<AptosResponse<Req, Res>> {
-  return get<Req, Res>({ ...options, type: AptosApiType.PEPPER });
-}
-
 /// This function is a helper for paginating using a function wrapping an API
 export async function paginateWithCursor<Req extends Record<string, any>, Res extends Array<{}>>(
   options: GetAptosRequestOptions,

package/src/client/post.ts

@@ -135,15 +135,3 @@ export async function postAptosFaucet<Req extends {}, Res extends {}>(
     },
   });
 }
-
-export async function postAptosPepperService<Req extends {}, Res extends {}>(
-  options: PostAptosRequestOptions,
-): Promise<AptosResponse<Req, Res>> {
-  return post<Req, Res>({ ...options, type: AptosApiType.PEPPER });
-}
-
-export async function postAptosProvingService<Req extends {}, Res extends {}>(
-  options: PostAptosRequestOptions,
-): Promise<AptosResponse<Req, Res>> {
-  return post<Req, Res>({ ...options, type: AptosApiType.PROVER });
-}

package/src/{account → core/account}/Account.ts

@@ -1,11 +1,10 @@
-import type { AccountAuthenticator } from "../transactions/authenticator/account";
-import { HexInput, SigningScheme, SigningSchemeInput } from "../types";
-import type { AccountAddress, AccountAddressInput } from "../core/accountAddress";
-import { AuthenticationKey } from "../core/authenticationKey";
-import { AccountPublicKey, Ed25519PrivateKey, PrivateKey, Signature, VerifySignatureArgs } from "../core/crypto";
+import type { AccountAuthenticator } from "../../transactions/authenticator/account";
+import { HexInput, SigningScheme, SigningSchemeInput } from "../../types";
+import type { AccountAddress, AccountAddressInput } from "../accountAddress";
+import { AuthenticationKey } from "../authenticationKey";
+import { AccountPublicKey, Ed25519PrivateKey, PrivateKey, Signature, VerifySignatureArgs } from "../crypto";
 import { Ed25519Account } from "./Ed25519Account";
 import { SingleKeyAccount } from "./SingleKeyAccount";
-import { AnyRawTransaction } from "../transactions/types";
 
 /**
  * Arguments for creating an `Ed25519Account` from an `Ed25519PrivateKey`.
@@ -107,6 +106,13 @@ export interface PrivateKeyFromDerivationPathArgs {
  * Note: Generating an account instance does not create the account on-chain.
  */
 export abstract class Account {
+  /**
+   * Private key associated with the account.
+   * Note: this will be removed in the next major release,
+   *  as not all accounts have a private key.
+   */
+  abstract readonly privateKey: PrivateKey;
+
   /**
    * Public key associated with the account
    */
@@ -216,11 +222,11 @@ export abstract class Account {
   }
 
   /**
-   * Sign a transaction using the available signing capabilities.
-   * @param transaction the raw transaction
-   * @return the AccountAuthenticator containing the signature og the transaction, together with the account's public key
+   * Sign a message using the available signing capabilities.
+   * @param message the signing message, as binary input
+   * @return the AccountAuthenticator containing the signature, together with the account's public key
    */
-  abstract signWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticator;
+  abstract signWithAuthenticator(message: HexInput): AccountAuthenticator;
 
   /**
    * Sign the given message with the private key.
@@ -229,8 +235,6 @@ export abstract class Account {
    */
   abstract sign(message: HexInput): Signature;
 
-  abstract signTransaction(transaction: AnyRawTransaction): Signature;
-
   /**
    * @param args.message raw message data in HexInput format
    * @param args.signature signed message signature

package/src/{account → core/account}/Ed25519Account.ts

@@ -1,10 +1,8 @@
-import { AccountAuthenticatorEd25519 } from "../transactions/authenticator/account";
-import { HexInput, SigningScheme } from "../types";
-import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
-import { Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature } from "../core/crypto";
+import { AccountAuthenticatorEd25519 } from "../../transactions/authenticator/account";
+import { HexInput, SigningScheme } from "../../types";
+import { AccountAddress, AccountAddressInput } from "../accountAddress";
+import { Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature } from "../crypto";
 import type { Account } from "./Account";
-import { AnyRawTransaction } from "../transactions/types";
-import { generateSigningMessageForTransaction } from "../transactions/transactionBuilder/signingMessage";
 
 export interface Ed25519SignerConstructorArgs {
   privateKey: Ed25519PrivateKey;
@@ -77,17 +75,13 @@ export class Ed25519Account implements Account {
     return this.publicKey.verifySignature(args);
   }
 
-  signWithAuthenticator(transaction: AnyRawTransaction) {
-    const signature = this.privateKey.sign(generateSigningMessageForTransaction(transaction));
+  signWithAuthenticator(message: HexInput) {
+    const signature = this.privateKey.sign(message);
     return new AccountAuthenticatorEd25519(this.publicKey, signature);
   }
 
   sign(message: HexInput) {
-    return this.privateKey.sign(message);
-  }
-
-  signTransaction(transaction: AnyRawTransaction) {
-    return this.sign(generateSigningMessageForTransaction(transaction));
+    return this.signWithAuthenticator(message).signature;
   }
 
   // endregion

package/src/{account → core/account}/SingleKeyAccount.ts

@@ -1,10 +1,8 @@
-import { AccountAuthenticatorSingleKey } from "../transactions/authenticator/account";
-import { type HexInput, SigningScheme, SigningSchemeInput } from "../types";
-import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
-import { AnyPublicKey, AnySignature, Ed25519PrivateKey, PrivateKey, Secp256k1PrivateKey } from "../core/crypto";
+import { AccountAuthenticatorSingleKey } from "../../transactions/authenticator/account";
+import { type HexInput, SigningScheme, SigningSchemeInput } from "../../types";
+import { AccountAddress, AccountAddressInput } from "../accountAddress";
+import { AnyPublicKey, AnySignature, Ed25519PrivateKey, PrivateKey, Secp256k1PrivateKey } from "../crypto";
 import type { Account } from "./Account";
-import { generateSigningMessageForTransaction } from "../transactions/transactionBuilder/signingMessage";
-import { AnyRawTransaction } from "../transactions/types";
 
 export interface SingleKeySignerConstructorArgs {
   privateKey: PrivateKey;
@@ -108,17 +106,14 @@ export class SingleKeyAccount implements Account {
     return this.publicKey.verifySignature(args);
   }
 
-  signWithAuthenticator(transaction: AnyRawTransaction) {
-    const signature = this.sign(generateSigningMessageForTransaction(transaction));
+  signWithAuthenticator(message: HexInput) {
+    const innerSignature = this.privateKey.sign(message);
+    const signature = new AnySignature(innerSignature);
     return new AccountAuthenticatorSingleKey(this.publicKey, signature);
   }
 
   sign(message: HexInput) {
-    return new AnySignature(this.privateKey.sign(message));
-  }
-
-  signTransaction(transaction: AnyRawTransaction) {
-    return this.sign(generateSigningMessageForTransaction(transaction));
+    return this.signWithAuthenticator(message).signature;
   }
 
   // endregion

package/src/core/account/index.ts

@@ -1,2 +1,4 @@
+export * from "./Ed25519Account";
+export * from "./Account";
+export * from "./SingleKeyAccount";
 export * from "./utils";
-

package/src/core/crypto/ed25519.ts

@@ -7,7 +7,7 @@ import { Serializable, Serializer } from "../../bcs/serializer";
 import { AuthenticationKey } from "../authenticationKey";
 import { Hex } from "../hex";
 import { HexInput, SigningScheme as AuthenticationKeyScheme } from "../../types";
-import { isValidHardenedPath, fromDerivationPath as fromDerivationPathInner, mnemonicToSeed } from "./hdKey";
+import { CKDPriv, deriveKey, HARDENED_OFFSET, isValidHardenedPath, mnemonicToSeed, splitPath } from "./hdKey";
 import { PrivateKey } from "./privateKey";
 import { AccountPublicKey, VerifySignatureArgs } from "./publicKey";
 import { Signature } from "./signature";
@@ -185,9 +185,29 @@ export class Ed25519PrivateKey extends Serializable implements PrivateKey {
     if (!isValidHardenedPath(path)) {
       throw new Error(`Invalid derivation path ${path}`);
     }
-    return new Ed25519PrivateKey(
-      fromDerivationPathInner(path, Ed25519PrivateKey.SLIP_0010_SEED, mnemonicToSeed(mnemonics)),
-    );
+    return Ed25519PrivateKey.fromDerivationPathInner(path, mnemonicToSeed(mnemonics));
+  }
+
+  /**
+   * A private inner function so we can separate from the main fromDerivationPath() method
+   * to add tests to verify we create the keys correctly.
+   *
+   * @param path the BIP44 path
+   * @param seed the seed phrase created by the mnemonics
+   * @param offset the offset used for key derivation, defaults to 0x80000000
+   * @returns
+   */
+  private static fromDerivationPathInner(path: string, seed: Uint8Array, offset = HARDENED_OFFSET): Ed25519PrivateKey {
+    const { key, chainCode } = deriveKey(Ed25519PrivateKey.SLIP_0010_SEED, seed);
+
+    const segments = splitPath(path).map((el) => parseInt(el, 10));
+
+    // Derive the child key based on the path
+    const { key: privateKey } = segments.reduce((parentKeys, segment) => CKDPriv(parentKeys, segment + offset), {
+      key,
+      chainCode,
+    });
+    return new Ed25519PrivateKey(privateKey);
   }
 
   // endregion

package/src/core/crypto/hdKey.ts

@@ -4,7 +4,6 @@
 import { hmac } from "@noble/hashes/hmac";
 import { sha512 } from "@noble/hashes/sha512";
 import * as bip39 from "@scure/bip39";
-import { HexInput } from "../../types";
 
 export type DerivedKeys = {
   key: Uint8Array;
@@ -16,7 +15,6 @@ export type DerivedKeys = {
  */
 export const APTOS_HARDENED_REGEX = /^m\/44'\/637'\/[0-9]+'\/[0-9]+'\/[0-9]+'?$/;
 export const APTOS_BIP44_REGEX = /^m\/44'\/637'\/[0-9]+'\/[0-9]+\/[0-9]+$/;
-export const APTOS_BIP44_DEFAULT_DERIVATION_PATH = "m/44'/637'/0'/0'/0'";
 
 /**
  * A list of supported key types and associated seeds
@@ -93,35 +91,6 @@ const removeApostrophes = (val: string): string => val.replace("'", "");
  */
 export const splitPath = (path: string): Array<string> => path.split("/").slice(1).map(removeApostrophes);
 
-/**
- * @param path the BIP44 path
- * @param seed the seed phrase created by the mnemonics
- * @param offset the offset used for key derivation, defaults to 0x80000000
- * @returns
- */
-export function fromDerivationPath(
-  path: string,
-  hashSeed: HexInput,
-  seed: Uint8Array,
-  offset = HARDENED_OFFSET,
-): Uint8Array {
-  if (offset === HARDENED_OFFSET && !isValidHardenedPath(path)) {
-    throw new Error(`Invalid hardened derivation path ${path}`);
-  } else if (offset !== HARDENED_OFFSET && !isValidBIP44Path(path)) {
-    throw new Error(`Invalid derivation path ${path}`);
-  }
-  const { key, chainCode } = deriveKey(hashSeed, seed);
-
-  const segments = splitPath(path).map((el) => parseInt(el, 10));
-
-  // Derive the child key based on the path
-  const { key: privateKey } = segments.reduce((parentKeys, segment) => CKDPriv(parentKeys, segment + offset), {
-    key,
-    chainCode,
-  });
-  return privateKey;
-}
-
 /**
  * Normalizes the mnemonic by removing extra whitespace and making it lowercase
  * @param mnemonic the mnemonic seed phrase

package/src/core/crypto/index.ts

@@ -5,8 +5,6 @@ export * from "./ed25519";
 export * from "./hdKey";
 export * from "./multiEd25519";
 export * from "./multiKey";
-export * from "./ephemeral";
-export * from "./keyless";
 export * from "./privateKey";
 export * from "./publicKey";
 export * from "./secp256k1";

package/src/core/crypto/multiKey.ts

@@ -139,19 +139,9 @@ export class MultiKey extends AccountPublicKey {
 
     return bitmap;
   }
-
-  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 not found in MultiKey");
-  }
 }
 
-export class MultiSignature extends Signature {
+export class MultiKeySignature extends Signature {
   /**
    * Number of bytes in the bitmap representing who signed the transaction (32-bits)
    */
@@ -160,7 +150,7 @@ export class MultiSignature extends Signature {
   /**
    * Maximum number of Ed25519 signatures supported
    */
-  static MAX_SIGNATURES_SUPPORTED = MultiSignature.BITMAP_LEN * 8;
+  static MAX_SIGNATURES_SUPPORTED = MultiKeySignature.BITMAP_LEN * 8;
 
   /**
    * The list of underlying Ed25519 signatures
@@ -188,8 +178,8 @@ export class MultiSignature extends Signature {
     super();
     const { signatures, bitmap } = args;
 
-    if (signatures.length > MultiSignature.MAX_SIGNATURES_SUPPORTED) {
-      throw new Error(`The number of signatures cannot be greater than ${MultiSignature.MAX_SIGNATURES_SUPPORTED}`);
+    if (signatures.length > MultiKeySignature.MAX_SIGNATURES_SUPPORTED) {
+      throw new Error(`The number of signatures cannot be greater than ${MultiKeySignature.MAX_SIGNATURES_SUPPORTED}`);
     }
 
     // Make sure that all signatures are normalized to the SingleKey authentication scheme
@@ -198,9 +188,9 @@ export class MultiSignature extends Signature {
     );
 
     if (!(bitmap instanceof Uint8Array)) {
-      this.bitmap = MultiSignature.createBitmap({ bits: bitmap });
-    } else if (bitmap.length !== MultiSignature.BITMAP_LEN) {
-      throw new Error(`"bitmap" length should be ${MultiSignature.BITMAP_LEN}`);
+      this.bitmap = MultiKeySignature.createBitmap({ bits: bitmap });
+    } else if (bitmap.length !== MultiKeySignature.BITMAP_LEN) {
+      throw new Error(`"bitmap" length should be ${MultiKeySignature.BITMAP_LEN}`);
     } else {
       this.bitmap = bitmap;
     }
@@ -236,8 +226,8 @@ export class MultiSignature extends Signature {
     const dupCheckSet = new Set();
 
     bits.forEach((bit: number) => {
-      if (bit >= MultiSignature.MAX_SIGNATURES_SUPPORTED) {
-        throw new Error(`Cannot have a signature larger than ${MultiSignature.MAX_SIGNATURES_SUPPORTED - 1}.`);
+      if (bit >= MultiKeySignature.MAX_SIGNATURES_SUPPORTED) {
+        throw new Error(`Cannot have a signature larger than ${MultiKeySignature.MAX_SIGNATURES_SUPPORTED - 1}.`);
       }
 
       if (dupCheckSet.has(bit)) {
@@ -275,7 +265,7 @@ export class MultiSignature extends Signature {
     serializer.serializeBytes(this.bitmap);
   }
 
-  static deserialize(deserializer: Deserializer): MultiSignature {
+  static deserialize(deserializer: Deserializer): MultiKeySignature {
     const bitmap = deserializer.deserializeBytes();
     const nSignatures = bitmap.reduce((acc, byte) => acc + bitCount(byte), 0);
     const signatures: AnySignature[] = [];
@@ -283,7 +273,7 @@ export class MultiSignature extends Signature {
       const signature = AnySignature.deserialize(deserializer);
       signatures.push(signature);
     }
-    return new MultiSignature({ signatures, bitmap });
+    return new MultiKeySignature({ signatures, bitmap });
   }
 
   // endregion

package/src/core/crypto/singleKey.ts

@@ -4,7 +4,6 @@ import { AuthenticationKey } from "../authenticationKey";
 import { Ed25519PublicKey, Ed25519Signature } from "./ed25519";
 import { AccountPublicKey, PublicKey, VerifySignatureArgs } from "./publicKey";
 import { Secp256k1PublicKey, Secp256k1Signature } from "./secp256k1";
-import { KeylessPublicKey, KeylessSignature } from "./keyless";
 import { Signature } from "./signature";
 
 /**
@@ -35,8 +34,6 @@ export class AnyPublicKey extends AccountPublicKey {
       this.variant = AnyPublicKeyVariant.Ed25519;
     } else if (publicKey instanceof Secp256k1PublicKey) {
       this.variant = AnyPublicKeyVariant.Secp256k1;
-    } else if (publicKey instanceof KeylessPublicKey) {
-      this.variant = AnyPublicKeyVariant.Keyless;
     } else {
       throw new Error("Unsupported public key type");
     }
@@ -88,9 +85,6 @@ export class AnyPublicKey extends AccountPublicKey {
       case AnyPublicKeyVariant.Secp256k1:
         publicKey = Secp256k1PublicKey.deserialize(deserializer);
         break;
-      case AnyPublicKeyVariant.Keyless:
-        publicKey = KeylessPublicKey.deserialize(deserializer);
-        break;
       default:
         throw new Error(`Unknown variant index for AnyPublicKey: ${variantIndex}`);
     }
@@ -144,8 +138,6 @@ export class AnySignature extends Signature {
       this.variant = AnySignatureVariant.Ed25519;
     } else if (signature instanceof Secp256k1Signature) {
       this.variant = AnySignatureVariant.Secp256k1;
-    } else if (signature instanceof KeylessSignature) {
-      this.variant = AnySignatureVariant.Keyless;
     } else {
       throw new Error("Unsupported signature type");
     }
@@ -178,9 +170,6 @@ export class AnySignature extends Signature {
       case AnySignatureVariant.Secp256k1:
         signature = Secp256k1Signature.deserialize(deserializer);
         break;
-      case AnySignatureVariant.Keyless:
-        signature = KeylessSignature.deserialize(deserializer);
-        break;
       default:
         throw new Error(`Unknown variant index for AnySignature: ${variantIndex}`);
     }

package/src/core/index.ts

@@ -1,6 +1,7 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
+export * from "./account";
 export * from "./accountAddress";
 export * from "./authenticationKey";
 export * from "./common";

package/src/index.ts

@@ -1,7 +1,6 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-export * from "./account";
 export * from "./api";
 export * from "./bcs";
 export * from "./client";

package/src/internal/account.ts

@@ -11,7 +11,7 @@
 import { AptosConfig } from "../api/aptosConfig";
 import { AptosApiError, getAptosFullNode, paginateWithCursor } from "../client";
 import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
-import { Account } from "../account";
+import { Account } from "../core/account";
 import { AnyPublicKey, Ed25519PublicKey, PrivateKey } from "../core/crypto";
 import { getTableItem, queryIndexer } from "./general";
 import {

package/src/internal/ans.ts

@@ -9,8 +9,7 @@
  */
 
 import { AptosConfig } from "../api/aptosConfig";
-import { Account } from "../account";
-import { AccountAddress, AccountAddressInput } from "../core";
+import { Account, AccountAddress, AccountAddressInput } from "../core";
 import { InputGenerateTransactionOptions } from "../transactions/types";
 import { GetANSNameResponse, MoveAddressType, OrderByArg, PaginationArgs, WhereArg } from "../types";
 import { GetNamesQuery } from "../types/generated/operations";

package/src/internal/digitalAsset.ts

@@ -10,8 +10,7 @@
 
 import { AptosConfig } from "../api/aptosConfig";
 import { Bool, MoveString, MoveVector, U64 } from "../bcs";
-import { AccountAddress, AccountAddressInput } from "../core";
-import { Account } from "../account";
+import { Account, AccountAddress, AccountAddressInput } from "../core";
 import { EntryFunctionABI, InputGenerateTransactionOptions } from "../transactions/types";
 import {
   AnyNumber,

package/src/internal/fungibleAsset.ts

@@ -33,8 +33,7 @@ import {
   FungibleAssetActivitiesBoolExp,
   FungibleAssetMetadataBoolExp,
 } from "../types/generated/types";
-import { AccountAddressInput } from "../core";
-import { Account } from "../account";
+import { Account, AccountAddressInput } from "../core";
 import {
   EntryFunctionABI,
   InputGenerateTransactionOptions,

package/src/internal/transactionSubmission.ts

@@ -8,7 +8,7 @@
 import { AptosConfig } from "../api/aptosConfig";
 import { MoveVector, U8 } from "../bcs";
 import { postAptosFullNode } from "../client";
-import { Account, KeylessAccount, MultiKeyAccount } from "../account";
+import { Account } from "../core/account";
 import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
 import { PrivateKey } from "../core/crypto";
 import { AccountAuthenticator } from "../transactions/authenticator/account";
@@ -18,6 +18,8 @@ import {
   generateTransactionPayload,
   generateSignedTransactionForSimulation,
   generateSignedTransaction,
+  sign,
+  generateSigningMessage,
 } from "../transactions/transactionBuilder/transactionBuilder";
 import {
   InputGenerateTransactionData,
@@ -33,7 +35,7 @@ import {
 } from "../transactions/types";
 import { getInfo } from "./account";
 import { UserTransactionResponse, PendingTransactionResponse, MimeType, HexInput, TransactionResponse } from "../types";
-import { TypeTagU8, TypeTagVector, generateSigningMessageForTransaction } from "../transactions";
+import { TypeTagU8, TypeTagVector } from "../transactions";
 import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
 import { MultiAgentTransaction } from "../transactions/instances/multiAgentTransaction";
 
@@ -183,7 +185,7 @@ function isMultiAgentTransactionInput(
  */
 export function getSigningMessage(args: { transaction: AnyRawTransaction }): Uint8Array {
   const { transaction } = args;
-  return generateSigningMessageForTransaction(transaction);
+  return generateSigningMessage(transaction);
 }
 
 /**
@@ -202,8 +204,8 @@ export function getSigningMessage(args: { transaction: AnyRawTransaction }): Uin
  * @return The signer AccountAuthenticator
  */
 export function signTransaction(args: { signer: Account; transaction: AnyRawTransaction }): AccountAuthenticator {
-  const { signer, transaction } = args;
-  return signer.signWithAuthenticator(transaction);
+  const accountAuthenticator = sign({ ...args });
+  return accountAuthenticator;
 }
 
 /**
@@ -275,9 +277,6 @@ export async function signAndSubmitTransaction(args: {
   transaction: AnyRawTransaction;
 }): Promise<PendingTransactionResponse> {
   const { aptosConfig, signer, transaction } = args;
-  if (signer instanceof KeylessAccount || signer instanceof MultiKeyAccount) {
-    await signer.waitForProofFetch();
-  }
   const authenticator = signTransaction({ signer, transaction });
   return submitTransaction({
     aptosConfig,

package/src/transactions/authenticator/account.ts

@@ -7,7 +7,7 @@ import { Serializer, Deserializer, Serializable } from "../../bcs";
 import { AnyPublicKey, AnySignature } from "../../core/crypto";
 import { Ed25519PublicKey, Ed25519Signature } from "../../core/crypto/ed25519";
 import { MultiEd25519PublicKey, MultiEd25519Signature } from "../../core/crypto/multiEd25519";
-import { MultiKey, MultiSignature } from "../../core/crypto/multiKey";
+import { MultiKey } from "../../core/crypto/multiKey";
 import { AccountAuthenticatorVariant } from "../../types";
 
 export abstract class AccountAuthenticator extends Serializable {
@@ -149,23 +149,28 @@ export class AccountAuthenticatorSingleKey extends AccountAuthenticator {
 export class AccountAuthenticatorMultiKey extends AccountAuthenticator {
   public readonly public_keys: MultiKey;
 
-  public readonly signatures: MultiSignature;
+  public readonly signatures: Array<AnySignature>;
 
-  constructor(public_keys: MultiKey, signatures: MultiSignature) {
+  public readonly signatures_bitmap: Uint8Array;
+
+  constructor(public_keys: MultiKey, signatures: Array<AnySignature>, signatures_bitmap: Uint8Array) {
     super();
     this.public_keys = public_keys;
     this.signatures = signatures;
+    this.signatures_bitmap = signatures_bitmap;
   }
 
   serialize(serializer: Serializer): void {
     serializer.serializeU32AsUleb128(AccountAuthenticatorVariant.MultiKey);
     this.public_keys.serialize(serializer);
-    this.signatures.serialize(serializer);
+    serializer.serializeVector<AnySignature>(this.signatures);
+    serializer.serializeBytes(this.signatures_bitmap);
   }
 
   static load(deserializer: Deserializer): AccountAuthenticatorMultiKey {
     const public_keys = MultiKey.deserialize(deserializer);
-    const signatures = MultiSignature.deserialize(deserializer);
-    return new AccountAuthenticatorMultiKey(public_keys, signatures);
+    const signatures = deserializer.deserializeVector(AnySignature);
+    const signatures_bitmap = deserializer.deserializeBytes();
+    return new AccountAuthenticatorMultiKey(public_keys, signatures, signatures_bitmap);
   }
 }

package/src/transactions/management/accountSequenceNumber.ts

@@ -24,7 +24,7 @@
  */
 
 import { AptosConfig } from "../../api/aptosConfig";
-import { Account } from "../../account";
+import { Account } from "../../core";
 import { getInfo } from "../../internal/account";
 import { sleep } from "../../utils/helpers";