@aptos-labs/ts-sdk 1.13.3-zeta.1 → 1.14.0

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";
@@ -79,7 +78,6 @@ const NetworkToAnsContract: Record<Network, string | null> = {
   [Network.LOCAL]: LOCAL_ANS_ACCOUNT_ADDRESS,
   [Network.CUSTOM]: null,
   [Network.DEVNET]: null,
-  [Network.RANDOMNET]: null,
 };
 
 function getRouterAddress(aptosConfig: AptosConfig): string {

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,
@@ -118,7 +117,7 @@ export async function getCurrentFungibleAssetBalances(args: {
 }
 
 const faTransferAbi: EntryFunctionABI = {
-  typeParameters: [],
+  typeParameters: [{ constraints: [] }],
   parameters: [parseTypeTag("0x1::object::Object"), new TypeTagAddress(), new TypeTagU64()],
 };
 

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";
 

package/src/transactions/management/transactionWorker.ts

@@ -2,7 +2,7 @@
 
 import EventEmitter from "eventemitter3";
 import { AptosConfig } from "../../api/aptosConfig";
-import { Account } from "../../account";
+import { Account } from "../../core";
 import { waitForTransaction } from "../../internal/transaction";
 import { generateTransaction, signAndSubmitTransaction } from "../../internal/transactionSubmission";
 import { PendingTransactionResponse, TransactionResponse } from "../../types";
@@ -233,13 +233,7 @@ export class TransactionWorker extends EventEmitter<TransactionWorkerEvents> {
   async checkTransaction(sentTransaction: PromiseFulfilledResult<PendingTransactionResponse>, sequenceNumber: bigint) {
     try {
       const waitFor: Array<Promise<TransactionResponse>> = [];
-      waitFor.push(
-        waitForTransaction({
-          aptosConfig: this.aptosConfig,
-          transactionHash: sentTransaction.value.hash,
-          options: { timeoutSecs: 3 },
-        }),
-      );
+      waitFor.push(waitForTransaction({ aptosConfig: this.aptosConfig, transactionHash: sentTransaction.value.hash }));
       const sentTransactions = await Promise.allSettled(waitFor);
 
       for (let i = 0; i < sentTransactions.length; i += 1) {

package/src/transactions/transactionBuilder/index.ts

@@ -4,4 +4,3 @@
 export * from "./helpers";
 export * from "./transactionBuilder";
 export * from "./remoteAbi";
-export * from "./signingMessage";

package/src/transactions/transactionBuilder/transactionBuilder.ts

@@ -9,13 +9,20 @@
 import { sha3_256 as sha3Hash } from "@noble/hashes/sha3";
 import { AptosConfig } from "../../api/aptosConfig";
 import { AccountAddress, AccountAddressInput, Hex, PublicKey } from "../../core";
+import { Account } from "../../core/account";
 import { AnyPublicKey, AnySignature } from "../../core/crypto";
 import { Ed25519PublicKey, Ed25519Signature } from "../../core/crypto/ed25519";
+import { Secp256k1PublicKey, Secp256k1Signature } from "../../core/crypto/secp256k1";
 import { getInfo } from "../../internal/account";
 import { getLedgerInfo } from "../../internal/general";
 import { getGasPriceEstimation } from "../../internal/transaction";
 import { NetworkToChainId } from "../../utils/apiEndpoints";
-import { DEFAULT_MAX_GAS_AMOUNT, DEFAULT_TXN_EXP_SEC_FROM_NOW } from "../../utils/const";
+import {
+  DEFAULT_MAX_GAS_AMOUNT,
+  DEFAULT_TXN_EXP_SEC_FROM_NOW,
+  RAW_TRANSACTION_SALT,
+  RAW_TRANSACTION_WITH_DATA_SALT,
+} from "../../utils/const";
 import { normalizeBundle } from "../../utils/normalizeBundle";
 import {
   AccountAuthenticator,
@@ -46,6 +53,7 @@ import { SignedTransaction } from "../instances/signedTransaction";
 import {
   AnyRawTransaction,
   AnyTransactionPayloadInstance,
+  AnyRawTransactionInstance,
   EntryFunctionArgumentTypes,
   InputGenerateMultiAgentRawTransactionArgs,
   InputGenerateRawTransactionArgs,
@@ -443,7 +451,12 @@ export function generateSignedTransactionForSimulation(args: InputSimulateTransa
 export function getAuthenticatorForSimulation(publicKey: PublicKey) {
   // TODO add support for AnyMultiKey
   if (publicKey instanceof AnyPublicKey) {
-    return new AccountAuthenticatorSingleKey(publicKey, new AnySignature(new Ed25519Signature(new Uint8Array(64))));
+    if (publicKey.publicKey instanceof Ed25519PublicKey) {
+      return new AccountAuthenticatorSingleKey(publicKey, new AnySignature(new Ed25519Signature(new Uint8Array(64))));
+    }
+    if (publicKey.publicKey instanceof Secp256k1PublicKey) {
+      return new AccountAuthenticatorSingleKey(publicKey, new AnySignature(new Secp256k1Signature(new Uint8Array(64))));
+    }
   }
 
   // legacy code
@@ -453,6 +466,24 @@ export function getAuthenticatorForSimulation(publicKey: PublicKey) {
   );
 }
 
+/**
+ * Sign a transaction that can later be submitted to chain
+ *
+ * @param args.signer The signer account to sign the transaction
+ * @param args.transaction A aptos transaction type to sign
+ *
+ * @return The signer AccountAuthenticator
+ */
+export function sign(args: { signer: Account; transaction: AnyRawTransaction }): AccountAuthenticator {
+  const { signer, transaction } = args;
+
+  // get the signing message
+  const message = generateSigningMessage(transaction);
+
+  // account.signMessage
+  return signer.signWithAuthenticator(message);
+}
+
 /**
  * Prepare a transaction to be submitted to chain
  *
@@ -534,52 +565,48 @@ export function generateUserTransactionHash(args: InputSubmitTransactionData): s
 }
 
 /**
- * Generate a multi signers signed transaction that can be submitted to chain
+ * Derive the raw transaction type - FeePayerRawTransaction or MultiAgentRawTransaction or RawTransaction
  *
- * @param transaction MultiAgentRawTransaction | FeePayerRawTransaction
- * @param senderAuthenticator The account authenticator of the transaction sender
- * @param secondarySignerAuthenticators The extra signers account Authenticators
+ * @param transaction A aptos transaction type
  *
- * @returns A SignedTransaction
+ * @returns FeePayerRawTransaction | MultiAgentRawTransaction | RawTransaction
  */
-export function generateMultiSignersSignedTransaction(
-  transaction: MultiAgentRawTransaction | FeePayerRawTransaction,
-  senderAuthenticator: AccountAuthenticator,
-  feePayerAuthenticator?: AccountAuthenticator,
-  additionalSignersAuthenticators?: Array<AccountAuthenticator>,
-) {
-  if (transaction instanceof FeePayerRawTransaction) {
-    if (!feePayerAuthenticator) {
-      throw new Error("Must provide a feePayerAuthenticator argument to generate a signed fee payer transaction");
-    }
-    const txAuthenticatorFeePayer = new TransactionAuthenticatorFeePayer(
-      senderAuthenticator,
-      transaction.secondary_signer_addresses,
-      additionalSignersAuthenticators ?? [],
-      {
-        address: transaction.fee_payer_address,
-        authenticator: feePayerAuthenticator,
-      },
+export function deriveTransactionType(transaction: AnyRawTransaction): AnyRawTransactionInstance {
+  if (transaction.feePayerAddress) {
+    return new FeePayerRawTransaction(
+      transaction.rawTransaction,
+      transaction.secondarySignerAddresses ?? [],
+      transaction.feePayerAddress,
     );
-    return new SignedTransaction(transaction.raw_txn, txAuthenticatorFeePayer).bcsToBytes();
   }
-  if (transaction instanceof MultiAgentRawTransaction) {
-    if (!additionalSignersAuthenticators) {
-      throw new Error(
-        "Must provide a additionalSignersAuthenticators argument to generate a signed multi agent transaction",
-      );
-    }
-    const multiAgentAuthenticator = new TransactionAuthenticatorMultiAgent(
-      senderAuthenticator,
-      transaction.secondary_signer_addresses,
-      additionalSignersAuthenticators ?? [],
-    );
-    return new SignedTransaction(transaction.raw_txn, multiAgentAuthenticator).bcsToBytes();
+  if (transaction.secondarySignerAddresses) {
+    return new MultiAgentRawTransaction(transaction.rawTransaction, transaction.secondarySignerAddresses);
   }
 
-  throw new Error(
-    `Cannot prepare multi signers transaction to submission, ${typeof transaction} transaction is not supported`,
-  );
+  return transaction.rawTransaction;
+}
+
+export function generateSigningMessage(transaction: AnyRawTransaction): Uint8Array {
+  const hash = sha3Hash.create();
+
+  if (transaction.feePayerAddress) {
+    hash.update(RAW_TRANSACTION_WITH_DATA_SALT);
+  } else if (transaction.secondarySignerAddresses) {
+    hash.update(RAW_TRANSACTION_WITH_DATA_SALT);
+  } else {
+    hash.update(RAW_TRANSACTION_SALT);
+  }
+
+  const prefix = hash.digest();
+
+  const rawTxn = deriveTransactionType(transaction);
+  const body = rawTxn.bcsToBytes();
+
+  const mergedArray = new Uint8Array(prefix.length + body.length);
+  mergedArray.set(prefix);
+  mergedArray.set(body, prefix.length);
+
+  return mergedArray;
 }
 
 /**