@aptos-labs/ts-sdk 1.11.0 → 1.12.0

package/src/api/ans.ts

@@ -1,7 +1,7 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { Account, AccountAddressInput } from "../core";
+import { Account, AccountAddress, AccountAddressInput } from "../core";
 import {
   RegisterNameParameters,
   getExpiration,
@@ -22,9 +22,10 @@ import {
   getDomainSubdomains,
   GetDomainSubdomainsArgs,
 } from "../internal/ans";
-import { GetANSNameResponse, MoveAddressType } from "../types";
-import { InputGenerateTransactionOptions, SimpleTransaction } from "../transactions/types";
+import { GetANSNameResponse } from "../types";
+import { InputGenerateTransactionOptions } from "../transactions/types";
 import { AptosConfig } from "./aptosConfig";
+import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
 
 /**
  * A class to handle all `ANS` operations
@@ -43,9 +44,9 @@ export class ANS {
    *
    * @param args.name - A string of the name to retrieve
    *
-   * @returns MoveAddressType if the name is owned, undefined otherwise
+   * @returns AccountAddress if the name is owned, undefined otherwise
    */
-  async getOwnerAddress(args: { name: string }): Promise<MoveAddressType | undefined> {
+  async getOwnerAddress(args: { name: string }): Promise<AccountAddress | undefined> {
     return getOwnerAddress({ aptosConfig: this.config, ...args });
   }
 
@@ -78,9 +79,9 @@ export class ANS {
    *
    * @param args.name - A string of the name: primary, primary.apt, secondary.primary, secondary.primary.apt, etc.
    *
-   * @returns MoveAddressType if the name has a target, undefined otherwise
+   * @returns AccountAddress if the name has a target, undefined otherwise
    */
-  async getTargetAddress(args: { name: string }): Promise<MoveAddressType | undefined> {
+  async getTargetAddress(args: { name: string }): Promise<AccountAddress | undefined> {
     return getTargetAddress({ aptosConfig: this.config, ...args });
   }
 

package/src/api/coin.ts

@@ -3,7 +3,8 @@
 
 import { AccountAddressInput } from "../core";
 import { transferCoinTransaction } from "../internal/coin";
-import { SimpleTransaction, InputGenerateTransactionOptions } from "../transactions/types";
+import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
+import { InputGenerateTransactionOptions } from "../transactions/types";
 import { AnyNumber, MoveStructId } from "../types";
 import { AptosConfig } from "./aptosConfig";
 

package/src/api/digitalAsset.ts

@@ -14,7 +14,7 @@ import {
   TokenStandardArg,
 } from "../types";
 import { Account, AccountAddress, AccountAddressInput } from "../core";
-import { InputGenerateTransactionOptions, SimpleTransaction } from "../transactions/types";
+import { InputGenerateTransactionOptions } from "../transactions/types";
 import {
   addDigitalAssetPropertyTransaction,
   addDigitalAssetTypedPropertyTransaction,
@@ -45,6 +45,7 @@ import {
 import { ProcessorType } from "../utils/const";
 import { AptosConfig } from "./aptosConfig";
 import { waitForIndexerOnVersion } from "./utils";
+import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
 
 /**
  * A class to query all `DigitalAsset` related queries on Aptos.

package/src/api/fungibleAsset.ts

@@ -24,7 +24,8 @@ import { ProcessorType } from "../utils/const";
 import { AptosConfig } from "./aptosConfig";
 import { waitForIndexerOnVersion } from "./utils";
 import { Account, AccountAddress } from "../core";
-import { InputGenerateTransactionOptions, SimpleTransaction } from "../transactions";
+import { InputGenerateTransactionOptions } from "../transactions";
+import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
 
 /**
  * A class to query all `FungibleAsset` related queries on Aptos.

package/src/api/transaction.ts

@@ -32,13 +32,13 @@ import {
   AnyRawTransaction,
   InputGenerateTransactionOptions,
   InputGenerateTransactionPayloadData,
-  SimpleTransaction,
 } from "../transactions";
 import { AccountAddressInput, Account, PrivateKey } from "../core";
 import { Build } from "./transactionSubmission/build";
 import { Simulate } from "./transactionSubmission/simulate";
 import { Submit } from "./transactionSubmission/submit";
 import { TransactionManagement } from "./transactionSubmission/management";
+import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
 
 export class Transaction {
   readonly config: AptosConfig;

package/src/api/transactionSubmission/build.ts

@@ -3,12 +3,9 @@
 
 import { AccountAddressInput } from "../../core";
 import { generateTransaction } from "../../internal/transactionSubmission";
-import {
-  InputGenerateTransactionPayloadData,
-  InputGenerateTransactionOptions,
-  SimpleTransaction,
-  MultiAgentTransaction,
-} from "../../transactions";
+import { InputGenerateTransactionPayloadData, InputGenerateTransactionOptions } from "../../transactions";
+import { MultiAgentTransaction } from "../../transactions/instances/multiAgentTransaction";
+import { SimpleTransaction } from "../../transactions/instances/simpleTransaction";
 import { AptosConfig } from "../aptosConfig";
 
 /**

package/src/cli/localNode.ts

@@ -3,7 +3,7 @@ import kill from "tree-kill";
 import { sleep } from "../utils/helpers";
 
 export class LocalNode {
-  readonly MAXIMUM_WAIT_TIME_SEC = 30;
+  readonly MAXIMUM_WAIT_TIME_SEC = 75;
 
   readonly READINESS_ENDPOINT = "http://127.0.0.1:8070/";
 

package/src/core/account/utils/address.ts

@@ -20,6 +20,24 @@ export const createObjectAddress = (creatorAddress: AccountAddress, seed: Uint8A
   return new AccountAddress(sha3_256(bytes));
 };
 
+/**
+ * Creates an resource address from creator address and seed
+ *
+ * @param creatorAddress The creator account address
+ * @param seed The seed in either Uint8Array | string type
+ *
+ * @returns The resource account address
+ */
+export const createResourceAddress = (creatorAddress: AccountAddress, seed: Uint8Array | string): AccountAddress => {
+  const creatorBytes = creatorAddress.bcsToBytes();
+
+  const seedBytes = typeof seed === "string" ? Buffer.from(seed, "utf8") : seed;
+
+  const bytes = new Uint8Array([...creatorBytes, ...seedBytes, DeriveScheme.DeriveResourceAccountAddress]);
+
+  return new AccountAddress(sha3_256(bytes));
+};
+
 /**
  * Creates a token object address from creator address, collection name and token name
  *

package/src/core/crypto/ed25519.ts

@@ -11,6 +11,7 @@ import { CKDPriv, deriveKey, HARDENED_OFFSET, isValidHardenedPath, mnemonicToSee
 import { PrivateKey } from "./privateKey";
 import { AccountPublicKey, VerifySignatureArgs } from "./publicKey";
 import { Signature } from "./signature";
+import { convertSigningMessage } from "./utils";
 
 /**
  * Represents the public key of an Ed25519 key pair.
@@ -52,7 +53,7 @@ export class Ed25519PublicKey extends AccountPublicKey {
 
   /**
    * Verifies a signed data with a public key
-   * @param args.message a signed message
+   * @param args.message a signed message as a Hex string or Uint8Array
    * @param args.signature the signature of the message
    */
   verifySignature(args: VerifySignatureArgs): boolean {
@@ -60,8 +61,8 @@ export class Ed25519PublicKey extends AccountPublicKey {
     if (!(signature instanceof Ed25519Signature)) {
       return false;
     }
-
-    const messageBytes = Hex.fromHexInput(message).toUint8Array();
+    const messageToVerify = convertSigningMessage(message);
+    const messageBytes = Hex.fromHexInput(messageToVerify).toUint8Array();
     const signatureBytes = signature.toUint8Array();
     const publicKeyBytes = this.key.toUint8Array();
     return nacl.sign.detached.verify(messageBytes, signatureBytes, publicKeyBytes);
@@ -213,11 +214,12 @@ export class Ed25519PrivateKey extends Serializable implements PrivateKey {
   /**
    * Sign the given message with the private key.
    *
-   * @param message in HexInput format
+   * @param message a message as a string or Uint8Array
    * @returns Signature
    */
   sign(message: HexInput): Ed25519Signature {
-    const messageBytes = Hex.fromHexInput(message).toUint8Array();
+    const messageToSign = convertSigningMessage(message);
+    const messageBytes = Hex.fromHexInput(messageToSign).toUint8Array();
     const signatureBytes = nacl.sign.detached(messageBytes, this.signingKeyPair.secretKey);
     return new Ed25519Signature(signatureBytes);
   }

package/src/core/crypto/secp256k1.ts

@@ -11,6 +11,7 @@ import { isValidBIP44Path, mnemonicToSeed } from "./hdKey";
 import { PrivateKey } from "./privateKey";
 import { PublicKey, VerifySignatureArgs } from "./publicKey";
 import { Signature } from "./signature";
+import { convertSigningMessage } from "./utils";
 
 /**
  * Represents the Secp256k1 ecdsa public key
@@ -46,8 +47,8 @@ export class Secp256k1PublicKey extends PublicKey {
     if (!(signature instanceof Secp256k1Signature)) {
       return false;
     }
-
-    const messageBytes = Hex.fromHexInput(message).toUint8Array();
+    const messageToVerify = convertSigningMessage(message);
+    const messageBytes = Hex.fromHexInput(messageToVerify).toUint8Array();
     const messageSha3Bytes = sha3_256(messageBytes);
     const signatureBytes = signature.toUint8Array();
     return secp256k1.verify(signatureBytes, messageSha3Bytes, this.key.toUint8Array());
@@ -165,11 +166,12 @@ export class Secp256k1PrivateKey extends Serializable implements PrivateKey {
   /**
    * Sign the given message with the private key.
    *
-   * @param message in HexInput format
+   * @param message a message as a string or Uint8Array
    * @returns Signature
    */
   sign(message: HexInput): Secp256k1Signature {
-    const messageBytes = Hex.fromHexInput(message);
+    const messageToSign = convertSigningMessage(message);
+    const messageBytes = Hex.fromHexInput(messageToSign);
     const messageHashBytes = sha3_256(messageBytes.toUint8Array());
     const signature = secp256k1.sign(messageHashBytes, this.key.toUint8Array());
     return new Secp256k1Signature(signature.toCompactRawBytes());

package/src/core/crypto/utils.ts

@@ -0,0 +1,24 @@
+import { HexInput } from "../../types";
+import { Hex } from "../hex";
+
+/**
+ * Helper function to convert a message to sign or to verify to a valid message input
+ *
+ * @param message a message as a string or Uint8Array
+ *
+ * @returns a valid HexInput - string or Uint8Array
+ */
+export const convertSigningMessage = (message: HexInput): HexInput => {
+  // if message is of type string, verify it is a valid Hex string
+  if (typeof message === "string") {
+    const isValid = Hex.isValid(message);
+    // If message is not a valid Hex string, convert it into a Buffer
+    if (!isValid.valid) {
+      return Buffer.from(message, "utf8");
+    }
+    // If message is a valid Hex string, return it
+    return message;
+  }
+  // message is a Uint8Array
+  return message;
+};

package/src/core/hex.ts

@@ -37,7 +37,7 @@ export enum HexInvalidReason {
  * with a leading 0x prefix, regardless of what the input format was.
  *
  * These are some other ways to chain the functions together:
- * - `Hex.fromString({ hexInput: "0x1f" }).toUint8Array()`
+ * - `Hex.fromHexString({ hexInput: "0x1f" }).toUint8Array()`
  * - `new Hex([1, 3]).toStringWithoutPrefix()`
  */
 export class Hex {
@@ -95,7 +95,7 @@ export class Hex {
    *
    * @returns Hex
    */
-  static fromString(str: string): Hex {
+  static fromHexString(str: string): Hex {
     let input = str;
 
     if (input.startsWith("0x")) {
@@ -132,7 +132,7 @@ export class Hex {
    */
   static fromHexInput(hexInput: HexInput): Hex {
     if (hexInput instanceof Uint8Array) return new Hex(hexInput);
-    return Hex.fromString(hexInput);
+    return Hex.fromHexString(hexInput);
   }
 
   // ===
@@ -150,7 +150,7 @@ export class Hex {
    */
   static isValid(str: string): ParsingResult<HexInvalidReason> {
     try {
-      Hex.fromString(str);
+      Hex.fromHexString(str);
       return { valid: true };
     } catch (error: any) {
       return {

package/src/internal/ans.ts

@@ -10,7 +10,7 @@
 
 import { AptosConfig } from "../api/aptosConfig";
 import { Account, AccountAddress, AccountAddressInput } from "../core";
-import { InputGenerateTransactionOptions, SimpleTransaction } from "../transactions/types";
+import { InputGenerateTransactionOptions } from "../transactions/types";
 import { GetANSNameResponse, MoveAddressType, OrderByArg, PaginationArgs, WhereArg } from "../types";
 import { GetNamesQuery } from "../types/generated/operations";
 import { GetNames } from "../types/generated/queries";
@@ -19,6 +19,7 @@ import { Network } from "../utils/apiEndpoints";
 import { queryIndexer } from "./general";
 import { view } from "./view";
 import { generateTransaction } from "./transactionSubmission";
+import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
 
 export const VALIDATION_RULES_DESCRIPTION = [
   "A name must be between 3 and 63 characters long,",
@@ -94,7 +95,10 @@ const unwrapOption = <T>(option: any): T | undefined => {
   return undefined;
 };
 
-export async function getOwnerAddress(args: { aptosConfig: AptosConfig; name: string }): Promise<string | undefined> {
+export async function getOwnerAddress(args: {
+  aptosConfig: AptosConfig;
+  name: string;
+}): Promise<AccountAddress | undefined> {
   const { aptosConfig, name } = args;
   const routerAddress = getRouterAddress(aptosConfig);
   const { domainName, subdomainName } = isValidANSName(name);
@@ -109,7 +113,7 @@ export async function getOwnerAddress(args: { aptosConfig: AptosConfig; name: st
 
   const owner = unwrapOption<MoveAddressType>(res[0]);
 
-  return owner ? AccountAddress.from(owner).toString() : undefined;
+  return owner ? AccountAddress.from(owner) : undefined;
 }
 
 export interface RegisterNameParameters {
@@ -289,7 +293,7 @@ export async function setPrimaryName(args: {
 export async function getTargetAddress(args: {
   aptosConfig: AptosConfig;
   name: string;
-}): Promise<MoveAddressType | undefined> {
+}): Promise<AccountAddress | undefined> {
   const { aptosConfig, name } = args;
   const routerAddress = getRouterAddress(aptosConfig);
   const { domainName, subdomainName } = isValidANSName(name);
@@ -303,7 +307,7 @@ export async function getTargetAddress(args: {
   });
 
   const target = unwrapOption<MoveAddressType>(res[0]);
-  return target ? AccountAddress.from(target).toString() : undefined;
+  return target ? AccountAddress.from(target) : undefined;
 }
 
 export async function setTargetAddress(args: {

package/src/internal/coin.ts

@@ -1,10 +1,11 @@
 import { AptosConfig } from "../api/aptosConfig";
 import { AccountAddressInput } from "../core";
-import { EntryFunctionABI, InputGenerateTransactionOptions, SimpleTransaction } from "../transactions/types";
+import { EntryFunctionABI, InputGenerateTransactionOptions } from "../transactions/types";
 import { AnyNumber, MoveStructId } from "../types";
 import { APTOS_COIN } from "../utils/const";
 import { generateTransaction } from "./transactionSubmission";
 import { TypeTagAddress, TypeTagU64 } from "../transactions";
+import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
 
 const coinTransferAbi: EntryFunctionABI = {
   typeParameters: [{ constraints: [] }],

package/src/internal/digitalAsset.ts

@@ -11,7 +11,7 @@
 import { AptosConfig } from "../api/aptosConfig";
 import { Bool, MoveString, MoveVector, U64 } from "../bcs";
 import { Account, AccountAddress, AccountAddressInput } from "../core";
-import { EntryFunctionABI, InputGenerateTransactionOptions, SimpleTransaction } from "../transactions/types";
+import { EntryFunctionABI, InputGenerateTransactionOptions } from "../transactions/types";
 import {
   AnyNumber,
   GetCollectionDataResponse,
@@ -53,6 +53,7 @@ import {
   TypeTagU64,
   TypeTagVector,
 } from "../transactions";
+import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
 
 // A property type map for the user input and what Move expects
 const PropertyTypeMap = {

package/src/internal/fungibleAsset.ts

@@ -38,11 +38,11 @@ import {
   EntryFunctionABI,
   InputGenerateTransactionOptions,
   parseTypeTag,
-  SimpleTransaction,
   TypeTagAddress,
   TypeTagU64,
 } from "../transactions";
 import { generateTransaction } from "./transactionSubmission";
+import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
 
 export async function getFungibleAssetMetadata(args: {
   aptosConfig: AptosConfig;

package/src/internal/transactionSubmission.ts

@@ -26,18 +26,18 @@ import {
   AnyRawTransaction,
   InputSimulateTransactionData,
   InputGenerateTransactionOptions,
-  SimpleTransaction,
   InputGenerateTransactionPayloadDataWithRemoteABI,
   InputSubmitTransactionData,
   InputGenerateMultiAgentRawTransactionData,
   InputGenerateSingleSignerRawTransactionData,
-  MultiAgentTransaction,
   AnyTransactionPayloadInstance,
   EntryFunctionABI,
 } from "../transactions/types";
 import { getInfo } from "./account";
 import { UserTransactionResponse, PendingTransactionResponse, MimeType, HexInput, TransactionResponse } from "../types";
 import { TypeTagU8, TypeTagVector } from "../transactions";
+import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
+import { MultiAgentTransaction } from "../transactions/instances/multiAgentTransaction";
 
 /**
  * We are defining function signatures, each with its specific input and output.

package/src/transactions/instances/index.ts

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

package/src/transactions/instances/multiAgentTransaction.ts

@@ -0,0 +1,68 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+/* eslint-disable @typescript-eslint/naming-convention */
+
+import { Deserializer } from "../../bcs/deserializer";
+import { Serializable, Serializer } from "../../bcs/serializer";
+import { AccountAddress } from "../../core";
+import { RawTransaction } from "./rawTransaction";
+
+/**
+ * Representation of a Raw Transaction that can serialized and deserialized
+ */
+export class MultiAgentTransaction extends Serializable {
+  public rawTransaction: RawTransaction;
+
+  public feePayerAddress?: AccountAddress | undefined;
+
+  public secondarySignerAddresses: AccountAddress[];
+
+  /**
+   * SimpleTransaction represents a simple transaction type of a single signer that
+   * can be submitted to Aptos chain for execution.
+   *
+   * SimpleTransaction metadata contains the Raw Transaction and an optional
+   * sponsor Account Address to pay the gas fees.
+   *
+   * @param rawTransaction The Raw Tranasaction
+   * @param feePayerAddress The sponsor Account Address
+   */
+  constructor(
+    rawTransaction: RawTransaction,
+    secondarySignerAddresses: AccountAddress[],
+    feePayerAddress?: AccountAddress,
+  ) {
+    super();
+    this.rawTransaction = rawTransaction;
+    this.feePayerAddress = feePayerAddress;
+    this.secondarySignerAddresses = secondarySignerAddresses;
+  }
+
+  serialize(serializer: Serializer): void {
+    this.rawTransaction.serialize(serializer);
+
+    serializer.serializeVector<AccountAddress>(this.secondarySignerAddresses);
+
+    if (this.feePayerAddress === undefined) {
+      serializer.serializeBool(false);
+    } else {
+      serializer.serializeBool(true);
+      this.feePayerAddress.serialize(serializer);
+    }
+  }
+
+  static deserialize(deserializer: Deserializer): MultiAgentTransaction {
+    const rawTransaction = RawTransaction.deserialize(deserializer);
+
+    const secondarySignerAddresses = deserializer.deserializeVector(AccountAddress);
+
+    const feepayerPresent = deserializer.deserializeBool();
+    let feePayerAddress;
+    if (feepayerPresent) {
+      feePayerAddress = AccountAddress.deserialize(deserializer);
+    }
+
+    return new MultiAgentTransaction(rawTransaction, secondarySignerAddresses, feePayerAddress);
+  }
+}

package/src/transactions/instances/simpleTransaction.ts

@@ -0,0 +1,60 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+/* eslint-disable @typescript-eslint/naming-convention */
+
+import { Deserializer } from "../../bcs/deserializer";
+import { Serializable, Serializer } from "../../bcs/serializer";
+import { AccountAddress } from "../../core";
+import { RawTransaction } from "./rawTransaction";
+
+/**
+ * Representation of a SimpleTransaction that can serialized and deserialized
+ */
+export class SimpleTransaction extends Serializable {
+  public rawTransaction: RawTransaction;
+
+  public feePayerAddress?: AccountAddress | undefined;
+
+  // We dont really need it, we add it for type checkings we do
+  // throughout the SDK
+  public readonly secondarySignerAddresses: undefined;
+
+  /**
+   * SimpleTransaction represents a simple transaction type of a single signer that
+   * can be submitted to Aptos chain for execution.
+   *
+   * SimpleTransaction metadata contains the Raw Transaction and an optional
+   * sponsor Account Address to pay the gas fees.
+   *
+   * @param rawTransaction The Raw Tranasaction
+   * @param feePayerAddress The sponsor Account Address
+   */
+  constructor(rawTransaction: RawTransaction, feePayerAddress?: AccountAddress) {
+    super();
+    this.rawTransaction = rawTransaction;
+    this.feePayerAddress = feePayerAddress;
+  }
+
+  serialize(serializer: Serializer): void {
+    this.rawTransaction.serialize(serializer);
+
+    if (this.feePayerAddress === undefined) {
+      serializer.serializeBool(false);
+    } else {
+      serializer.serializeBool(true);
+      this.feePayerAddress.serialize(serializer);
+    }
+  }
+
+  static deserialize(deserializer: Deserializer): SimpleTransaction {
+    const rawTransaction = RawTransaction.deserialize(deserializer);
+    const feepayerPresent = deserializer.deserializeBool();
+    let feePayerAddress;
+    if (feepayerPresent) {
+      feePayerAddress = AccountAddress.deserialize(deserializer);
+    }
+
+    return new SimpleTransaction(rawTransaction, feePayerAddress);
+  }
+}

package/src/transactions/management/transactionWorker.ts

@@ -6,9 +6,10 @@ import { Account } from "../../core";
 import { waitForTransaction } from "../../internal/transaction";
 import { generateTransaction, signAndSubmitTransaction } from "../../internal/transactionSubmission";
 import { PendingTransactionResponse, TransactionResponse } from "../../types";
-import { InputGenerateTransactionOptions, InputGenerateTransactionPayloadData, SimpleTransaction } from "../types";
+import { InputGenerateTransactionOptions, InputGenerateTransactionPayloadData } from "../types";
 import { AccountSequenceNumber } from "./accountSequenceNumber";
 import { AsyncQueue, AsyncQueueCancelledError } from "./asyncQueue";
+import { SimpleTransaction } from "../instances/simpleTransaction";
 
 export const promiseFulfilledStatus = "fulfilled";
 

package/src/transactions/transactionBuilder/transactionBuilder.ts

@@ -57,9 +57,7 @@ import {
   InputGenerateMultiAgentRawTransactionArgs,
   InputGenerateRawTransactionArgs,
   InputGenerateSingleSignerRawTransactionArgs,
-  SimpleTransaction,
   InputGenerateTransactionOptions,
-  MultiAgentTransaction,
   InputScriptData,
   InputSimulateTransactionData,
   InputMultiSigDataWithRemoteABI,
@@ -77,6 +75,8 @@ import { convertArgument, fetchEntryFunctionAbi, fetchViewFunctionAbi, standardi
 import { memoizeAsync } from "../../utils/memoize";
 import { AnyNumber } from "../../types";
 import { getFunctionParts, isScriptDataInput } from "./helpers";
+import { SimpleTransaction } from "../instances/simpleTransaction";
+import { MultiAgentTransaction } from "../instances/multiAgentTransaction";
 
 /**
  * We are defining function signatures, each with its specific input and output.
@@ -347,17 +347,14 @@ export async function buildTransaction(args: InputGenerateRawTransactionArgs): P
     const signers: Array<AccountAddress> =
       args.secondarySignerAddresses?.map((signer) => AccountAddress.from(signer)) ?? [];
 
-    return {
-      rawTransaction: rawTxn,
-      secondarySignerAddresses: signers,
-      feePayerAddress: args.feePayerAddress ? AccountAddress.from(args.feePayerAddress) : undefined,
-    };
+    return new MultiAgentTransaction(
+      rawTxn,
+      signers,
+      args.feePayerAddress ? AccountAddress.from(args.feePayerAddress) : undefined,
+    );
   }
   // return the raw transaction
-  return {
-    rawTransaction: rawTxn,
-    feePayerAddress: args.feePayerAddress ? AccountAddress.from(args.feePayerAddress) : undefined,
-  };
+  return new SimpleTransaction(rawTxn, args.feePayerAddress ? AccountAddress.from(args.feePayerAddress) : undefined);
 }
 
 /**
@@ -527,6 +524,36 @@ export function generateSignedTransaction(args: InputSubmitTransactionData): Uin
   );
 }
 
+/**
+ * Hashes the set of values with a SHA-3 256 hash
+ * @param input array of UTF-8 strings or Uint8array byte arrays
+ */
+export function hashValues(input: (Uint8Array | string)[]): Uint8Array {
+  const hash = sha3Hash.create();
+  for (const item of input) {
+    hash.update(item);
+  }
+  return hash.digest();
+}
+
+/**
+ * The domain separated prefix for hashing transacitons
+ */
+const TRANSACTION_PREFIX = hashValues(["APTOS::Transaction"]);
+
+/**
+ * Generates a user transaction hash for the given transaction payload.  It must already have an authenticator
+ * @param args InputSubmitTransactionData
+ */
+export function generateUserTransactionHash(args: InputSubmitTransactionData): string {
+  const signedTransaction = generateSignedTransaction(args);
+
+  // Transaction signature is defined as, the domain separated prefix based on struct (Transaction)
+  // Then followed by the type of the transaction for the enum, UserTransaction is 0
+  // Then followed by BCS encoded bytes of the signed transaction
+  return new Hex(hashValues([TRANSACTION_PREFIX, new Uint8Array([0]), signedTransaction])).toString();
+}
+
 /**
  * Derive the raw transaction type - FeePayerRawTransaction or MultiAgentRawTransaction or RawTransaction
  *