@aptos-labs/ts-sdk 0.0.5 → 0.0.7

package/src/internal/transactionSubmission.ts

@@ -25,13 +25,29 @@ import {
   AnyRawTransaction,
   InputSimulateTransactionData,
   InputGenerateTransactionOptions,
-  InputSingleSignerTransaction,
+  SingleSignerTransaction,
   InputGenerateTransactionPayloadDataWithRemoteABI,
   InputSubmitTransactionData,
+  InputGenerateMultiAgentRawTransactionData,
+  InputGenerateSingleSignerRawTransactionData,
+  MultiAgentTransaction,
+  AnyTransactionPayloadInstance,
 } from "../transactions/types";
 import { getInfo } from "./account";
 import { UserTransactionResponse, PendingTransactionResponse, MimeType, HexInput, TransactionResponse } from "../types";
 
+/**
+ * We are defining function signatures, each with its specific input and output.
+ * These are the possible function signature for `generateTransaction` function.
+ * When we call `generateTransaction` function with the relevant type properties,
+ * Typescript can infer the return type based on the appropriate function overload.
+ */
+export async function generateTransaction(
+  args: { aptosConfig: AptosConfig } & InputGenerateSingleSignerRawTransactionData,
+): Promise<SingleSignerTransaction>;
+export async function generateTransaction(
+  args: { aptosConfig: AptosConfig } & InputGenerateMultiAgentRawTransactionData,
+): Promise<MultiAgentTransaction>;
 /**
  * Generates any transaction by passing in the required arguments
  *
@@ -75,18 +91,14 @@ import { UserTransactionResponse, PendingTransactionResponse, MimeType, HexInput
 export async function generateTransaction(
   args: { aptosConfig: AptosConfig } & InputGenerateTransactionData,
 ): Promise<AnyRawTransaction> {
-  const { aptosConfig, sender, data, options, secondarySignerAddresses, hasFeePayer } = args;
-
-  // Upate feePayerAddress if it has sponsor
-  let feePayerAddress;
-  if (hasFeePayer === true) {
-    feePayerAddress = AccountAddress.ZERO.toString();
-  }
+  const { aptosConfig, sender, data, options } = args;
 
   // Merge in aptosConfig for remote ABI on non-script payloads
   let generateTransactionPayloadData: InputGenerateTransactionPayloadDataWithRemoteABI;
+  let payload: AnyTransactionPayloadInstance;
   if ("bytecode" in data) {
     generateTransactionPayloadData = data;
+    payload = await generateTransactionPayload(generateTransactionPayloadData);
   } else if ("multisigAddress" in data) {
     generateTransactionPayloadData = {
       aptosConfig,
@@ -95,6 +107,7 @@ export async function generateTransaction(
       functionArguments: data.functionArguments,
       typeArguments: data.typeArguments,
     };
+    payload = await generateTransactionPayload(generateTransactionPayloadData);
   } else {
     generateTransactionPayloadData = {
       aptosConfig,
@@ -102,18 +115,45 @@ export async function generateTransaction(
       functionArguments: data.functionArguments,
       typeArguments: data.typeArguments,
     };
+    payload = await generateTransactionPayload(generateTransactionPayloadData);
+  }
+
+  let feePayerAddress;
+  if (isFeePayerTransactionInput(args)) {
+    feePayerAddress = AccountAddress.ZERO.toString();
+  }
+
+  if (isMultiAgentTransactionInput(args)) {
+    const { secondarySignerAddresses } = args;
+    return buildTransaction({
+      aptosConfig,
+      sender,
+      payload,
+      options,
+      secondarySignerAddresses,
+      feePayerAddress,
+    });
   }
-  const payload = await generateTransactionPayload(generateTransactionPayloadData);
+
   return buildTransaction({
     aptosConfig,
     sender,
     payload,
     options,
-    secondarySignerAddresses,
     feePayerAddress,
   });
 }
 
+function isFeePayerTransactionInput(data: InputGenerateTransactionData): boolean {
+  return data.withFeePayer === true;
+}
+
+function isMultiAgentTransactionInput(
+  data: InputGenerateTransactionData,
+): data is InputGenerateMultiAgentRawTransactionData {
+  return "secondarySignerAddresses" in data;
+}
+
 /**
  * Sign a transaction that can later be submitted to chain
  *
@@ -217,7 +257,7 @@ export async function publicPackageTransaction(args: {
   metadataBytes: HexInput;
   moduleBytecode: Array<HexInput>;
   options?: InputGenerateTransactionOptions;
-}): Promise<InputSingleSignerTransaction> {
+}): Promise<SingleSignerTransaction> {
   const { aptosConfig, account, metadataBytes, moduleBytecode, options } = args;
 
   const totalByteCode = moduleBytecode.map((bytecode) => MoveVector.U8(bytecode));
@@ -231,7 +271,7 @@ export async function publicPackageTransaction(args: {
     },
     options,
   });
-  return transaction as InputSingleSignerTransaction;
+  return transaction as SingleSignerTransaction;
 }
 
 /**

package/src/transactions/transactionBuilder/helpers.ts

@@ -10,7 +10,7 @@ import {
 } from "../types";
 import { Bool, FixedBytes, MoveString, U128, U16, U256, U32, U64, U8 } from "../../bcs";
 import { AccountAddress } from "../../core";
-import { MoveFunction, MoveStructType } from "../../types";
+import { MoveFunction, MoveFunctionId } from "../../types";
 
 export function isBool(arg: SimpleEntryFunctionArgumentTypes): arg is boolean {
   return typeof arg === "boolean";
@@ -91,7 +91,7 @@ export function findFirstNonSignerArg(functionAbi: MoveFunction): number {
   return index;
 }
 
-export function getFunctionParts(functionArg: MoveStructType) {
+export function getFunctionParts(functionArg: MoveFunctionId) {
   const funcNameParts = functionArg.split("::");
   if (funcNameParts.length !== 3) {
     throw new Error(`Invalid function ${functionArg}`);

package/src/transactions/transactionBuilder/transactionBuilder.ts

@@ -8,7 +8,6 @@
  */
 import { sha3_256 as sha3Hash } from "@noble/hashes/sha3";
 import { AptosConfig } from "../../api/aptosConfig";
-import { Deserializer } from "../../bcs/deserializer";
 import { AccountAddress, AccountAddressInput, Hex, PublicKey } from "../../core";
 import { Account } from "../../core/account";
 import { AnyPublicKey } from "../../core/crypto/anyPublicKey";
@@ -57,14 +56,12 @@ import {
   AnyRawTransactionInstance,
   EntryFunctionArgumentTypes,
   EntryFunctionABI,
-  InputGenerateFeePayerRawTransactionArgs,
   InputGenerateMultiAgentRawTransactionArgs,
   InputGenerateRawTransactionArgs,
   InputGenerateSingleSignerRawTransactionArgs,
-  InputSingleSignerTransaction,
+  SingleSignerTransaction,
   InputGenerateTransactionOptions,
-  InputFeePayerTransaction,
-  InputMultiAgentTransaction,
+  MultiAgentTransaction,
   InputScriptData,
   InputSimulateTransactionData,
   InputGenerateTransactionPayloadData,
@@ -86,18 +83,13 @@ import { getFunctionParts, isScriptDataInput } from "./helpers";
  * When we call our `generateTransactionPayload` function with the relevant type properties,
  * Typescript can infer the return type based on the appropriate function overload.
  */
-export async function generateTransactionPayload(
-  args: InputScriptData & { aptosConfig?: undefined },
-): Promise<TransactionPayloadScript>;
+export async function generateTransactionPayload(args: InputScriptData): Promise<TransactionPayloadScript>;
 export async function generateTransactionPayload(
   args: InputEntryFunctionDataWithRemoteABI,
 ): Promise<TransactionPayloadEntryFunction>;
 export async function generateTransactionPayload(
   args: InputMultiSigDataWithRemoteABI,
 ): Promise<TransactionPayloadMultisig>;
-export async function generateTransactionPayload(
-  args: InputGenerateTransactionPayloadDataWithRemoteABI,
-): Promise<AnyTransactionPayloadInstance>;
 
 /**
  * Builds a transaction payload based on the data argument and returns
@@ -234,7 +226,7 @@ export async function generateRawTransaction(args: {
   );
 
   const { maxGasAmount, gasUnitPrice, expireTimestamp } = {
-    maxGasAmount: BigInt(DEFAULT_MAX_GAS_AMOUNT),
+    maxGasAmount: options?.maxGasAmount ? BigInt(options.maxGasAmount) : BigInt(DEFAULT_MAX_GAS_AMOUNT),
     gasUnitPrice: BigInt(gasEstimate),
     expireTimestamp: BigInt(Math.floor(Date.now() / 1000) + DEFAULT_TXN_EXP_SEC_FROM_NOW),
     ...options,
@@ -259,14 +251,9 @@ export async function generateRawTransaction(args: {
  */
 export async function buildTransaction(
   args: InputGenerateSingleSignerRawTransactionArgs,
-): Promise<InputSingleSignerTransaction>;
-export async function buildTransaction(
-  args: InputGenerateFeePayerRawTransactionArgs,
-): Promise<InputFeePayerTransaction>;
-export async function buildTransaction(
-  args: InputGenerateMultiAgentRawTransactionArgs,
-): Promise<InputMultiAgentTransaction>;
-export async function buildTransaction(args: InputGenerateRawTransactionArgs): Promise<AnyRawTransaction>;
+): Promise<SingleSignerTransaction>;
+export async function buildTransaction(args: InputGenerateMultiAgentRawTransactionArgs): Promise<MultiAgentTransaction>;
+
 /**
  * Generates a transaction based on the provided arguments
  *
@@ -290,7 +277,7 @@ export async function buildTransaction(args: InputGenerateRawTransactionArgs): P
  * ```
  */
 export async function buildTransaction(args: InputGenerateRawTransactionArgs): Promise<AnyRawTransaction> {
-  const { aptosConfig, sender, payload, options, secondarySignerAddresses, feePayerAddress } = args;
+  const { aptosConfig, sender, payload, options } = args;
   // generate raw transaction
   const rawTxn = await generateRawTransaction({
     aptosConfig,
@@ -299,28 +286,22 @@ export async function buildTransaction(args: InputGenerateRawTransactionArgs): P
     options,
   });
 
-  if (feePayerAddress) {
-    const signers: Array<AccountAddress> = secondarySignerAddresses
-      ? secondarySignerAddresses.map((signer) => AccountAddress.fromRelaxed(signer))
-      : [];
-
-    return {
-      rawTransaction: rawTxn,
-      secondarySignerAddresses: signers,
-      feePayerAddress: AccountAddress.fromRelaxed(feePayerAddress),
-    };
-  }
-
-  if (secondarySignerAddresses) {
-    const signers: Array<AccountAddress> = secondarySignerAddresses.map((signer) => AccountAddress.fromRelaxed(signer));
+  // if multi agent transaction
+  if ("secondarySignerAddresses" in args) {
+    const signers: Array<AccountAddress> =
+      args.secondarySignerAddresses?.map((signer) => AccountAddress.fromRelaxed(signer)) ?? [];
 
     return {
       rawTransaction: rawTxn,
       secondarySignerAddresses: signers,
+      feePayerAddress: args.feePayerAddress ? AccountAddress.fromRelaxed(args.feePayerAddress) : undefined,
     };
   }
   // return the raw transaction
-  return { rawTransaction: rawTxn };
+  return {
+    rawTransaction: rawTxn,
+    feePayerAddress: args.feePayerAddress ? AccountAddress.fromRelaxed(args.feePayerAddress) : undefined,
+  };
 }
 
 /**
@@ -337,25 +318,21 @@ export async function buildTransaction(args: InputGenerateRawTransactionArgs): P
 export function generateSignedTransactionForSimulation(args: InputSimulateTransactionData): Uint8Array {
   const { signerPublicKey, transaction, secondarySignersPublicKeys, feePayerPublicKey } = args;
 
-  const deserializer = new Deserializer(transaction.rawTransaction.bcsToBytes());
-  const deserializedTransaction = RawTransaction.deserialize(deserializer);
-
   const accountAuthenticator = getAuthenticatorForSimulation(signerPublicKey);
+
   // fee payer transaction
   if (transaction.feePayerAddress) {
     const transactionToSign = new FeePayerRawTransaction(
-      deserializedTransaction,
+      transaction.rawTransaction,
       transaction.secondarySignerAddresses ?? [],
       transaction.feePayerAddress,
     );
-
     let secondaryAccountAuthenticators: Array<AccountAuthenticator> = [];
     if (secondarySignersPublicKeys) {
       secondaryAccountAuthenticators = secondarySignersPublicKeys.map((publicKey) =>
         getAuthenticatorForSimulation(publicKey),
       );
     }
-
     const feePayerAuthenticator = getAuthenticatorForSimulation(feePayerPublicKey!);
 
     const transactionAuthenticator = new TransactionAuthenticatorFeePayer(
@@ -373,7 +350,7 @@ export function generateSignedTransactionForSimulation(args: InputSimulateTransa
   // multi agent transaction
   if (transaction.secondarySignerAddresses) {
     const transactionToSign = new MultiAgentRawTransaction(
-      deserializedTransaction,
+      transaction.rawTransaction,
       transaction.secondarySignerAddresses,
     );
 
@@ -392,7 +369,7 @@ export function generateSignedTransactionForSimulation(args: InputSimulateTransa
     return new SignedTransaction(transactionToSign.raw_txn, transactionAuthenticator).bcsToBytes();
   }
 
-  // raw transaction
+  // single signer raw transaction
   let transactionAuthenticator;
   if (accountAuthenticator instanceof AccountAuthenticatorEd25519) {
     transactionAuthenticator = new TransactionAuthenticatorEd25519(
@@ -404,7 +381,7 @@ export function generateSignedTransactionForSimulation(args: InputSimulateTransa
   } else {
     throw new Error("Invalid public key");
   }
-  return new SignedTransaction(deserializedTransaction, transactionAuthenticator).bcsToBytes();
+  return new SignedTransaction(transaction.rawTransaction, transactionAuthenticator).bcsToBytes();
 }
 
 export function getAuthenticatorForSimulation(publicKey: PublicKey) {
@@ -419,7 +396,6 @@ export function getAuthenticatorForSimulation(publicKey: PublicKey) {
   }
 
   // legacy code
-  // TODO add support to legacy multied25519
   return new AccountAuthenticatorEd25519(
     new Ed25519PublicKey(publicKey.toUint8Array()),
     new Ed25519Signature(new Uint8Array(64)),

package/src/transactions/typeTag/parser.ts

@@ -29,6 +29,10 @@ function isValidWhitespaceCharacter(char: string) {
   return !!char.match(/\s/);
 }
 
+function isGeneric(str: string) {
+  return !!str.match(/^T[0-9]+$/);
+}
+
 function consumeWhitespace(tagStr: string, pos: number) {
   let i = pos;
   for (; i < tagStr.length; i += 1) {
@@ -50,6 +54,7 @@ type TypeTagState = {
 
 export enum TypeTagParserErrorType {
   InvalidTypeTag = "unknown type",
+  UnexpectedGenericType = "unexpected generic type",
   UnexpectedTypeArgumentClose = "unexpected '>'",
   UnexpectedWhitespaceCharacter = "unexpected whitespace character",
   UnexpectedComma = "unexpected ','",
@@ -262,8 +267,11 @@ function parseTypeTagInner(str: string, types: Array<TypeTag>, allowGenerics: bo
       }
       return new TypeTagVector(types[0]);
     default:
-      if (allowGenerics && str.match(/^T[0-9]+$/)) {
-        return new TypeTagGeneric(Number(str.split("T")[1]));
+      if (isGeneric(str)) {
+        if (allowGenerics) {
+          return new TypeTagGeneric(Number(str.split("T")[1]));
+        }
+        throw new TypeTagParserError(str, TypeTagParserErrorType.UnexpectedGenericType);
       }
 
       // If the value doesn't contain a colon, then we'll assume it isn't trying to be a struct

package/src/transactions/types.ts

@@ -15,7 +15,7 @@ import {
   TransactionPayloadMultisig,
   TransactionPayloadScript,
 } from "./instances";
-import { AnyNumber, HexInput, MoveFunctionGenericTypeParam, MoveStructType } from "../types";
+import { AnyNumber, HexInput, MoveFunctionGenericTypeParam, MoveFunctionId } from "../types";
 import { TypeTag } from "./typeTag";
 import { AccountAuthenticator } from "./authenticator/account";
 
@@ -97,7 +97,7 @@ export type AnyTransactionPayloadInstance =
 export type InputGenerateTransactionPayloadData = InputEntryFunctionData | InputScriptData | InputMultiSigData;
 
 export type InputGenerateTransactionPayloadDataWithRemoteABI =
-  | (InputScriptData & { aptosConfig?: undefined })
+  | InputScriptData
   | InputEntryFunctionDataWithRemoteABI
   | InputMultiSigDataWithRemoteABI;
 
@@ -105,7 +105,7 @@ export type InputGenerateTransactionPayloadDataWithRemoteABI =
  * The data needed to generate an Entry Function payload
  */
 export type InputEntryFunctionData = {
-  function: MoveStructType;
+  function: MoveFunctionId;
   typeArguments?: Array<TypeTag | string>;
   functionArguments: Array<EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes>;
 };
@@ -152,22 +152,8 @@ export interface InputGenerateSingleSignerRawTransactionArgs {
   aptosConfig: AptosConfig;
   sender: AccountAddressInput;
   payload: AnyTransactionPayloadInstance;
-  feePayerAddress?: undefined;
-  secondarySignerAddresses?: undefined;
-  options?: InputGenerateTransactionOptions;
-}
-
-/**
- * Interface of the arguments to generate a fee payer transaction.
- * Used to provide to `generateTransaction()` method in the transaction builder flow
- */
-export interface InputGenerateFeePayerRawTransactionArgs {
-  aptosConfig: AptosConfig;
-  sender: AccountAddressInput;
-  payload: AnyTransactionPayloadInstance;
-  feePayerAddress: AccountAddressInput;
-  secondarySignerAddresses?: AccountAddressInput[];
   options?: InputGenerateTransactionOptions;
+  feePayerAddress?: AccountAddressInput;
 }
 
 /**
@@ -179,8 +165,8 @@ export interface InputGenerateMultiAgentRawTransactionArgs {
   sender: AccountAddressInput;
   payload: AnyTransactionPayloadInstance;
   secondarySignerAddresses: AccountAddressInput[];
-  feePayerAddress?: undefined;
   options?: InputGenerateTransactionOptions;
+  feePayerAddress?: AccountAddressInput;
 }
 
 /**
@@ -188,7 +174,6 @@ export interface InputGenerateMultiAgentRawTransactionArgs {
  */
 export type InputGenerateRawTransactionArgs =
   | InputGenerateSingleSignerRawTransactionArgs
-  | InputGenerateFeePayerRawTransactionArgs
   | InputGenerateMultiAgentRawTransactionArgs;
 
 /**
@@ -196,41 +181,28 @@ export type InputGenerateRawTransactionArgs =
  *
  * @param rawTransaction a bcs serialized raw transaction
  */
-export interface InputSingleSignerTransaction {
+export interface SingleSignerTransaction {
   rawTransaction: RawTransaction;
-  feePayerAddress?: undefined;
+  feePayerAddress?: AccountAddress;
   secondarySignerAddresses?: undefined;
 }
 
-/**
- * Interface that holds the return data when generating a fee payer transaction
- *
- * @param rawTransaction a bcs serialized raw transaction
- * @param secondarySignerAddresses optional. secondary signer addresses for multi-agent transaction
- * @param feePayerAddress fee payer address for a fee payer transaction (aka Sponsored Transaction)
- */
-export interface InputFeePayerTransaction {
-  rawTransaction: RawTransaction;
-  feePayerAddress: AccountAddress;
-  secondarySignerAddresses?: AccountAddress[];
-}
-
 /**
  * Interface that holds the return data when generating a multi-agent transaction.
  *
  * @param rawTransaction a bcs serialized raw transaction
  * @param secondarySignerAddresses secondary signer addresses for multi-agent transaction
  */
-export interface InputMultiAgentTransaction {
+export interface MultiAgentTransaction {
   rawTransaction: RawTransaction;
   secondarySignerAddresses: AccountAddress[];
-  feePayerAddress?: undefined;
+  feePayerAddress?: AccountAddress;
 }
 
 /**
  * Unified type that holds all the return interfaces when generating different transaction types
  */
-export type AnyRawTransaction = InputSingleSignerTransaction | InputFeePayerTransaction | InputMultiAgentTransaction;
+export type AnyRawTransaction = SingleSignerTransaction | MultiAgentTransaction;
 
 // TRANSACTION SIMULATION TYPES //
 
@@ -267,21 +239,10 @@ export type InputSimulateTransactionOptions = {
  */
 export interface InputGenerateSingleSignerRawTransactionData {
   sender: AccountAddressInput;
-  hasFeePayer?: undefined;
-  secondarySignerAddresses?: undefined;
-  options?: InputGenerateTransactionOptions;
   data: InputGenerateTransactionPayloadData;
-}
-
-/**
- * Interface that holds the user data input when generating a fee payer transaction
- */
-export interface InputGenerateFeePayerRawTransactionData {
-  sender: AccountAddressInput;
-  hasFeePayer: true;
-  secondarySignerAddresses?: AccountAddressInput[];
   options?: InputGenerateTransactionOptions;
-  data: InputGenerateTransactionPayloadData;
+  withFeePayer?: boolean;
+  secondarySignerAddresses?: undefined;
 }
 
 /**
@@ -289,19 +250,18 @@ export interface InputGenerateFeePayerRawTransactionData {
  */
 export interface InputGenerateMultiAgentRawTransactionData {
   sender: AccountAddressInput;
+  data: InputGenerateTransactionPayloadData;
   secondarySignerAddresses: AccountAddressInput[];
-  hasFeePayer?: undefined;
   options?: InputGenerateTransactionOptions;
-  data: InputGenerateTransactionPayloadData;
+  withFeePayer?: boolean;
 }
 
 /**
  * Unified type that holds all the user data input interfaces when generating different transaction types
  */
 export type InputGenerateTransactionData =
-  | InputGenerateMultiAgentRawTransactionData
-  | InputGenerateFeePayerRawTransactionData
-  | InputGenerateSingleSignerRawTransactionData;
+  | InputGenerateSingleSignerRawTransactionData
+  | InputGenerateMultiAgentRawTransactionData;
 
 /**
  * Interface that holds the user data input when submitting a transaction