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

package/src/core/crypto/poseidon.ts

@@ -0,0 +1,134 @@
+/* eslint-disable no-bitwise */
+import {
+  poseidon1,
+  poseidon2,
+  poseidon3,
+  poseidon4,
+  poseidon5,
+  poseidon6,
+  poseidon7,
+  poseidon8,
+  poseidon9,
+  poseidon10,
+  poseidon11,
+  poseidon12,
+  poseidon13,
+  poseidon14,
+  poseidon15,
+  poseidon16,
+} from "poseidon-lite";
+
+const numInputsToPoseidonFunc = [
+  poseidon1,
+  poseidon2,
+  poseidon3,
+  poseidon4,
+  poseidon5,
+  poseidon6,
+  poseidon7,
+  poseidon8,
+  poseidon9,
+  poseidon10,
+  poseidon11,
+  poseidon12,
+  poseidon13,
+  poseidon14,
+  poseidon15,
+  poseidon16,
+];
+
+const BYTES_PACKED_PER_SCALAR = 31;
+const MAX_NUM_INPUT_SCALARS = 16;
+const MAX_NUM_INPUT_BYTES = (MAX_NUM_INPUT_SCALARS - 1) * BYTES_PACKED_PER_SCALAR;
+
+// hashes an ASCII string to a field element
+export function hashASCIIStrToField(str: string, maxSizeBytes: number) {
+  const textEncoder = new TextEncoder();
+  const strBytes = textEncoder.encode(str);
+  return hashBytesWithLen(strBytes, maxSizeBytes);
+}
+
+function hashBytesWithLen(bytes: Uint8Array, maxSizeBytes: number) {
+  if (bytes.length > maxSizeBytes) {
+    throw new Error(`Inputted bytes of length ${bytes} is longer than ${maxSizeBytes}`);
+  }
+  const packed = padAndPackBytesWithLen(bytes, maxSizeBytes);
+  return poseidonHash(packed);
+}
+
+function padAndPackBytesNoLen(bytes: Uint8Array, maxSizeBytes: number): bigint[] {
+  if (bytes.length > maxSizeBytes) {
+    throw new Error(`Input bytes of length ${bytes} is longer than ${maxSizeBytes}`);
+  }
+  const paddedStrBytes = padUint8ArrayWithZeros(bytes, maxSizeBytes);
+  return packBytes(paddedStrBytes);
+}
+
+export function padAndPackBytesWithLen(bytes: Uint8Array, maxSizeBytes: number): bigint[] {
+  if (bytes.length > maxSizeBytes) {
+    throw new Error(`Input bytes of length ${bytes} is longer than ${maxSizeBytes}`);
+  }
+  return padAndPackBytesNoLen(bytes, maxSizeBytes).concat([BigInt(bytes.length)]);
+}
+
+function packBytes(bytes: Uint8Array): bigint[] {
+  if (bytes.length > MAX_NUM_INPUT_BYTES) {
+    throw new Error(`Can't pack more than ${MAX_NUM_INPUT_BYTES}.  Was given ${bytes.length} bytes`);
+  }
+  return chunkUint8Array(bytes, BYTES_PACKED_PER_SCALAR).map((chunk) => bytesToBigIntLE(chunk));
+}
+
+function chunkUint8Array(array: Uint8Array, chunkSize: number): Uint8Array[] {
+  const result: Uint8Array[] = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    result.push(array.subarray(i, i + chunkSize));
+  }
+  return result;
+}
+
+export function bytesToBigIntLE(bytes: Uint8Array): bigint {
+  let result = BigInt(0);
+  for (let i = bytes.length - 1; i >= 0; i -= 1) {
+    result = (result << BigInt(8)) | BigInt(bytes[i]);
+  }
+  return result;
+}
+
+export function bigIntToBytesLE(value: bigint, length: number): Uint8Array {
+  const bytes = new Uint8Array(length);
+  for (let i = 0; i < length; i += 1) {
+    bytes[i] = Number(value & BigInt(0xff));
+    // eslint-disable-next-line no-param-reassign
+    value >>= BigInt(8);
+  }
+  return bytes;
+}
+
+// From chatGPT
+function padUint8ArrayWithZeros(inputArray: Uint8Array, paddedSize: number): Uint8Array {
+  if (paddedSize < inputArray.length) {
+    throw new Error("Padded size must be greater than or equal to the input array size.");
+  }
+
+  // Create a new Uint8Array with the padded size
+  const paddedArray = new Uint8Array(paddedSize);
+
+  // Copy the content of the input array to the new array
+  paddedArray.set(inputArray);
+
+  // Fill the remaining space with zeros
+  for (let i = inputArray.length; i < paddedSize; i += 1) {
+    paddedArray[i] = 0;
+  }
+
+  return paddedArray;
+}
+
+export function poseidonHash(inputs: (number | bigint | string)[]): bigint {
+  const poseidonFixedHash = numInputsToPoseidonFunc[inputs.length - 1];
+
+  if (poseidonFixedHash) {
+    return poseidonFixedHash(inputs);
+  }
+  throw new Error(`Unable to hash input of length ${inputs.length}`);
+}

package/src/core/crypto/singleKey.ts

@@ -4,6 +4,7 @@ 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";
 
 /**
@@ -34,6 +35,8 @@ 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");
     }
@@ -85,6 +88,9 @@ 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}`);
     }
@@ -138,6 +144,8 @@ 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");
     }
@@ -170,6 +178,9 @@ 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,7 +1,6 @@
 // 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,6 +1,7 @@
 // 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 "../core/account";
+import { Account } from "../account";
 import { AnyPublicKey, Ed25519PublicKey, PrivateKey } from "../core/crypto";
 import { getTableItem, queryIndexer } from "./general";
 import {

package/src/internal/ans.ts

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

package/src/internal/fungibleAsset.ts

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

package/src/internal/keyless.ts

@@ -0,0 +1,185 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * This file contains the underlying implementations for exposed API surface in
+ * the {@link api/oidb}. By moving the methods out into a separate file,
+ * other namespaces and processes can access these methods without depending on the entire
+ * faucet namespace and without having a dependency cycle error.
+ */
+import { jwtDecode } from "jwt-decode";
+import { bls12_381 as bls } from "@noble/curves/bls12-381";
+import { ProjPointType } from "@noble/curves/abstract/weierstrass";
+import { AptosConfig } from "../api/aptosConfig";
+import { getAptosPepperService, postAptosPepperService, postAptosProvingService } from "../client";
+import {
+  APTOS_BIP44_DEFAULT_DERIVATION_PATH,
+  EPK_HORIZON_SECS,
+  EphemeralSignature,
+  Groth16Zkp,
+  Hex,
+  SignedGroth16Signature,
+} from "../core";
+import { HexInput } from "../types";
+import { Serializer } from "../bcs";
+import { EphemeralKeyPair, KeylessAccount } from "../account";
+import { PepperFetchResponse, ProverResponse } from "../types/keyless";
+
+const APTOS_KEYLESS_PEPPER_PINKAS_VUF_DST = "APTOS_KEYLESS_PEPPER_PINKAS_VUF_DST";
+
+function stringToUint8Array(str: string): Uint8Array {
+  const encoder = new TextEncoder();
+  return encoder.encode(str);
+}
+
+const PINKAS_VUF_SECRET_KEY_BASE_AFFINE = bls.G2.hashToCurve(
+  stringToUint8Array("APTOS_KEYLESS_PEPPER_PINKAS_VUF_SECRET_KEY_BASE"),
+  { DST: APTOS_KEYLESS_PEPPER_PINKAS_VUF_DST },
+).toAffine();
+
+function getPepperInput(args: { jwt: string; uidKey?: string }): ProjPointType<bigint> {
+  const { jwt, uidKey } = args;
+  const jwtPayload = jwtDecode<{ [key: string]: string }>(jwt);
+  const serializer = new Serializer();
+  serializer.serializeStr(jwtPayload.iss);
+  serializer.serializeStr(jwtPayload.aud);
+  serializer.serializeStr(jwtPayload[uidKey || "sub"]);
+  serializer.serializeStr(uidKey || "sub");
+  const serial = serializer.toUint8Array();
+  const msg = bls.G1.hashToCurve(serial, { DST: "APTOS_PEPPER_SERVICE_BLS12381_VUF_DST" }).toAffine();
+  const pp = bls.G1.ProjectivePoint.fromAffine(msg);
+  return pp;
+}
+
+async function verifyPepperBase(args: {
+  aptosConfig: AptosConfig;
+  pepperInput: ProjPointType<bigint>;
+  pepperBase: Uint8Array;
+}): Promise<boolean> {
+  const { aptosConfig, pepperInput, pepperBase } = args;
+  const { data: pubKeyResponse } = await getAptosPepperService<any, { vrf_public_key_hex_string: string }>({
+    aptosConfig,
+    path: "vrf-pub-key",
+    originMethod: "getPepper",
+  });
+  const publicKeyFromService = bls.G2.ProjectivePoint.fromHex(pubKeyResponse.vrf_public_key_hex_string);
+  return bls.verifyShortSignature(pepperBase, pepperInput, publicKeyFromService);
+}
+
+export async function getPepper(args: {
+  aptosConfig: AptosConfig;
+  jwt: string;
+  ephemeralKeyPair: EphemeralKeyPair;
+  uidKey?: string;
+  derivationPath?: string;
+  verify?: boolean;
+}): Promise<Uint8Array> {
+  const { aptosConfig, jwt, ephemeralKeyPair, uidKey, verify } = args;
+  let { derivationPath } = args;
+
+  const body = {
+    jwt_b64: jwt,
+    epk: ephemeralKeyPair.getPublicKey().bcsToHex().toStringWithoutPrefix(),
+    exp_date_secs: Number(ephemeralKeyPair.expiryDateSecs),
+    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),
+    uid_key: uidKey,
+  };
+  // console.log(JSON.stringify(body));
+  const { data } = await postAptosPepperService<any, PepperFetchResponse>({
+    aptosConfig,
+    path: "fetch",
+    body,
+    originMethod: "getPepper",
+    overrides: { WITH_CREDENTIALS: false },
+  });
+  const pepperBase = Hex.fromHexInput(data.signature).toUint8Array();
+
+  if (verify) {
+    const pepperVerified = verifyPepperBase({ aptosConfig, pepperBase, pepperInput: getPepperInput(args) });
+    if (!pepperVerified) {
+      throw new Error("Unable to verify");
+    }
+  }
+  // This takes the BLS VUF H(m)^sk and transforms it into a Pinkas VUF e(H(m), g_3^sk), where g_3 is the base of the secret key (computed pseudo-randomly via hash-to-curve).
+  // This gives us the freedom of either decentralizing the pepper service as a BLS-based MPC or on top of the validators, by reusing the Pinkas WVUF-based randomness infrastructure.
+  const newPepperBase = bls.pairing(
+    bls.G1.ProjectivePoint.fromHex(pepperBase),
+    bls.G2.ProjectivePoint.fromAffine(PINKAS_VUF_SECRET_KEY_BASE_AFFINE),
+  );
+
+  if (derivationPath === undefined) {
+    derivationPath = APTOS_BIP44_DEFAULT_DERIVATION_PATH;
+  }
+  const pepper = KeylessAccount.fromDerivationPath(derivationPath, bls.fields.Fp12.toBytes(newPepperBase));
+  return pepper.slice(0, 31);
+}
+
+export async function getProof(args: {
+  aptosConfig: AptosConfig;
+  jwt: string;
+  ephemeralKeyPair: EphemeralKeyPair;
+  pepper: HexInput;
+  uidKey?: string;
+  extraFieldKey?: string;
+}): Promise<SignedGroth16Signature> {
+  const { aptosConfig, jwt, ephemeralKeyPair, pepper, uidKey, extraFieldKey } = args;
+  const jwtPayload = jwtDecode<{ [key: string]: string }>(jwt);
+  let extraField;
+  if (extraFieldKey) {
+    const extraFieldVal = jwtPayload[extraFieldKey];
+    extraField = `"${extraFieldKey}":"${extraFieldVal}",`;
+  }
+  const json = {
+    jwt_b64: jwt,
+    epk: ephemeralKeyPair.getPublicKey().bcsToHex().toStringWithoutPrefix(),
+    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),
+    exp_date_secs: Number(ephemeralKeyPair.expiryDateSecs),
+    exp_horizon_secs: EPK_HORIZON_SECS,
+    pepper: Hex.fromHexInput(pepper).toStringWithoutPrefix(),
+    extra_field: extraFieldKey,
+    uid_key: uidKey || "sub",
+  };
+
+  const { data } = await postAptosProvingService<any, ProverResponse>({
+    aptosConfig,
+    path: "prove",
+    body: json,
+    originMethod: "getProof",
+    overrides: { WITH_CREDENTIALS: false },
+  });
+
+  const proofPoints = data.proof;
+  const proof = new Groth16Zkp({
+    a: proofPoints.a,
+    b: proofPoints.b,
+    c: proofPoints.c,
+  });
+
+  const signedProof = new SignedGroth16Signature({
+    proof,
+    extraField,
+    trainingWheelsSignature: EphemeralSignature.fromHex(data.training_wheels_signature),
+  });
+  return signedProof;
+}
+
+export async function deriveKeylessAccount(args: {
+  aptosConfig: AptosConfig;
+  jwt: string;
+  ephemeralKeyPair: EphemeralKeyPair;
+  uidKey?: string;
+  pepper?: HexInput;
+  extraFieldKey?: string;
+}): Promise<KeylessAccount> {
+  let { pepper } = args;
+  if (pepper === undefined) {
+    pepper = await getPepper(args);
+  } else if (Hex.fromHexInput(pepper).toUint8Array().length !== 31) {
+    throw new Error("Pepper needs to be 31 bytes");
+  }
+  const proof = await getProof({ ...args, pepper });
+
+  const keylessAccount = KeylessAccount.fromJWTAndProof({ ...args, proof, pepper });
+
+    return keylessAccount;
+}

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 } from "../core/account";
+import { Account, KeylessAccount, MultiKeyAccount } from "../account";
 import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
 import { PrivateKey } from "../core/crypto";
 import { AccountAuthenticator } from "../transactions/authenticator/account";
@@ -18,8 +18,6 @@ import {
   generateTransactionPayload,
   generateSignedTransactionForSimulation,
   generateSignedTransaction,
-  sign,
-  generateSigningMessage,
 } from "../transactions/transactionBuilder/transactionBuilder";
 import {
   InputGenerateTransactionData,
@@ -35,7 +33,7 @@ import {
 } from "../transactions/types";
 import { getInfo } from "./account";
 import { UserTransactionResponse, PendingTransactionResponse, MimeType, HexInput, TransactionResponse } from "../types";
-import { TypeTagU8, TypeTagVector } from "../transactions";
+import { TypeTagU8, TypeTagVector, generateSigningMessageForTransaction } from "../transactions";
 import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
 import { MultiAgentTransaction } from "../transactions/instances/multiAgentTransaction";
 
@@ -185,7 +183,7 @@ function isMultiAgentTransactionInput(
  */
 export function getSigningMessage(args: { transaction: AnyRawTransaction }): Uint8Array {
   const { transaction } = args;
-  return generateSigningMessage(transaction);
+  return generateSigningMessageForTransaction(transaction);
 }
 
 /**
@@ -204,8 +202,8 @@ export function getSigningMessage(args: { transaction: AnyRawTransaction }): Uin
  * @return The signer AccountAuthenticator
  */
 export function signTransaction(args: { signer: Account; transaction: AnyRawTransaction }): AccountAuthenticator {
-  const accountAuthenticator = sign({ ...args });
-  return accountAuthenticator;
+  const { signer, transaction } = args;
+  return signer.signWithAuthenticator(transaction);
 }
 
 /**
@@ -277,6 +275,9 @@ 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 } from "../../core/crypto/multiKey";
+import { MultiKey, MultiSignature } from "../../core/crypto/multiKey";
 import { AccountAuthenticatorVariant } from "../../types";
 
 export abstract class AccountAuthenticator extends Serializable {
@@ -149,28 +149,23 @@ export class AccountAuthenticatorSingleKey extends AccountAuthenticator {
 export class AccountAuthenticatorMultiKey extends AccountAuthenticator {
   public readonly public_keys: MultiKey;
 
-  public readonly signatures: Array<AnySignature>;
+  public readonly signatures: MultiSignature;
 
-  public readonly signatures_bitmap: Uint8Array;
-
-  constructor(public_keys: MultiKey, signatures: Array<AnySignature>, signatures_bitmap: Uint8Array) {
+  constructor(public_keys: MultiKey, signatures: MultiSignature) {
     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);
-    serializer.serializeVector<AnySignature>(this.signatures);
-    serializer.serializeBytes(this.signatures_bitmap);
+    this.signatures.serialize(serializer);
   }
 
   static load(deserializer: Deserializer): AccountAuthenticatorMultiKey {
     const public_keys = MultiKey.deserialize(deserializer);
-    const signatures = deserializer.deserializeVector(AnySignature);
-    const signatures_bitmap = deserializer.deserializeBytes();
-    return new AccountAuthenticatorMultiKey(public_keys, signatures, signatures_bitmap);
+    const signatures = MultiSignature.deserialize(deserializer);
+    return new AccountAuthenticatorMultiKey(public_keys, signatures);
   }
 }

package/src/transactions/instances/index.ts

@@ -10,3 +10,4 @@ export * from "./signedTransaction";
 export * from "./transactionArgument";
 export * from "./transactionPayload";
 export * from "./simpleTransaction";
+export * from "./multiAgentTransaction";

package/src/transactions/management/accountSequenceNumber.ts

@@ -24,7 +24,7 @@
  */
 
 import { AptosConfig } from "../../api/aptosConfig";
-import { Account } from "../../core";
+import { Account } from "../../account";
 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 "../../core";
+import { Account } from "../../account";
 import { waitForTransaction } from "../../internal/transaction";
 import { generateTransaction, signAndSubmitTransaction } from "../../internal/transactionSubmission";
 import { PendingTransactionResponse, TransactionResponse } from "../../types";
@@ -233,7 +233,13 @@ 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 }));
+      waitFor.push(
+        waitForTransaction({
+          aptosConfig: this.aptosConfig,
+          transactionHash: sentTransaction.value.hash,
+          options: { timeoutSecs: 3 },
+        }),
+      );
       const sentTransactions = await Promise.allSettled(waitFor);
 
       for (let i = 0; i < sentTransactions.length; i += 1) {

package/src/transactions/transactionBuilder/index.ts

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

package/src/transactions/transactionBuilder/signingMessage.ts

@@ -0,0 +1,70 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * This file handles the transaction creation lifecycle.
+ * It holds different operations to generate a transaction payload, a raw transaction,
+ * and a signed transaction that can be simulated, signed and submitted to chain.
+ */
+import { sha3_256 as sha3Hash } from "@noble/hashes/sha3";
+import { RAW_TRANSACTION_SALT, RAW_TRANSACTION_WITH_DATA_SALT } from "../../utils/const";
+import { FeePayerRawTransaction, MultiAgentRawTransaction, RawTransaction } from "../instances";
+import { AnyRawTransaction, AnyRawTransactionInstance } from "../types";
+import { Serializable } from "../../bcs";
+
+/**
+ * Derive the raw transaction type - FeePayerRawTransaction or MultiAgentRawTransaction or RawTransaction
+ *
+ * @param transaction A aptos transaction type
+ *
+ * @returns FeePayerRawTransaction | MultiAgentRawTransaction | RawTransaction
+ */
+export function deriveTransactionType(transaction: AnyRawTransaction): AnyRawTransactionInstance {
+  if (transaction.feePayerAddress) {
+    return new FeePayerRawTransaction(
+      transaction.rawTransaction,
+      transaction.secondarySignerAddresses ?? [],
+      transaction.feePayerAddress,
+    );
+  }
+  if (transaction.secondarySignerAddresses) {
+    return new MultiAgentRawTransaction(transaction.rawTransaction, transaction.secondarySignerAddresses);
+  }
+
+  return transaction.rawTransaction;
+}
+
+export function generateSigningMessage(bytes: Uint8Array, domainSeparator: string): Uint8Array {
+  const hash = sha3Hash.create();
+
+  if (!domainSeparator.startsWith("APTOS::")) {
+    throw new Error(`Domain separator needs to start with 'APTOS::'.  Provided - ${domainSeparator}`);
+  }
+
+  hash.update(domainSeparator);
+
+  const prefix = hash.digest();
+
+  const body = bytes;
+
+  const mergedArray = new Uint8Array(prefix.length + body.length);
+  mergedArray.set(prefix);
+  mergedArray.set(body, prefix.length);
+
+  return mergedArray;
+}
+
+export function generateSigningMessageForSerializable(obj: Serializable): Uint8Array {
+  return generateSigningMessage(obj.bcsToBytes(), obj.constructor.name);
+}
+
+export function generateSigningMessageForTransaction(transaction: AnyRawTransaction): Uint8Array {
+  const rawTxn = deriveTransactionType(transaction);
+  if (rawTxn instanceof RawTransaction) {
+    return generateSigningMessage(rawTxn.bcsToBytes(), RAW_TRANSACTION_SALT);
+  }
+  if (rawTxn instanceof MultiAgentRawTransaction || rawTxn instanceof FeePayerRawTransaction) {
+    return generateSigningMessage(rawTxn.bcsToBytes(), RAW_TRANSACTION_WITH_DATA_SALT);
+  }
+  throw new Error(`Unknown transaction type to sign on: ${rawTxn}`);
+}