@aptos-labs/ts-sdk 0.0.6 → 0.0.8

package/src/internal/event.ts

@@ -10,7 +10,7 @@
 
 import { AptosConfig } from "../api/aptosConfig";
 import { AccountAddress, AccountAddressInput } from "../core";
-import { AnyNumber, GetEventsResponse, PaginationArgs, MoveStructId, OrderBy } from "../types";
+import { AnyNumber, GetEventsResponse, PaginationArgs, MoveStructId, OrderByArg, WhereArg } from "../types";
 import { GetEventsQuery } from "../types/generated/operations";
 import { GetEvents } from "../types/generated/queries";
 import { EventsBoolExp } from "../types/generated/types";
@@ -36,13 +36,10 @@ export async function getAccountEventsByEventType(args: {
   aptosConfig: AptosConfig;
   accountAddress: AccountAddressInput;
   eventType: MoveStructId;
-  options?: {
-    pagination?: PaginationArgs;
-    orderBy?: OrderBy<GetEventsResponse[0]>;
-  };
+  options?: PaginationArgs & OrderByArg<GetEventsResponse[0]>;
 }): Promise<GetEventsResponse> {
   const { accountAddress, aptosConfig, eventType, options } = args;
-  const address = AccountAddress.fromRelaxed(accountAddress).toStringLong();
+  const address = AccountAddress.from(accountAddress).toStringLong();
 
   const whereCondition: EventsBoolExp = {
     account_address: { _eq: address },
@@ -51,7 +48,7 @@ export async function getAccountEventsByEventType(args: {
 
   const customOptions = {
     where: whereCondition,
-    pagination: options?.pagination,
+    pagination: options,
     orderBy: options?.orderBy,
   };
 
@@ -60,11 +57,7 @@ export async function getAccountEventsByEventType(args: {
 
 export async function getEvents(args: {
   aptosConfig: AptosConfig;
-  options?: {
-    where?: EventsBoolExp;
-    pagination?: PaginationArgs;
-    orderBy?: OrderBy<GetEventsResponse[0]>;
-  };
+  options?: PaginationArgs & OrderByArg<GetEventsResponse[0]> & WhereArg<EventsBoolExp>;
 }): Promise<GetEventsResponse> {
   const { aptosConfig, options } = args;
 
@@ -72,8 +65,8 @@ export async function getEvents(args: {
     query: GetEvents,
     variables: {
       where_condition: options?.where,
-      offset: options?.pagination?.offset,
-      limit: options?.pagination?.limit,
+      offset: options?.offset,
+      limit: options?.limit,
       order_by: options?.orderBy,
     },
   };

package/src/internal/faucet.ts

@@ -11,7 +11,7 @@
 import { AptosConfig } from "../api/aptosConfig";
 import { postAptosFaucet } from "../client";
 import { AccountAddress, AccountAddressInput } from "../core";
-import { WaitForTransactionOptions } from "../types";
+import { TransactionResponseType, UserTransactionResponse, WaitForTransactionOptions } from "../types";
 import { DEFAULT_TXN_TIMEOUT_SEC } from "../utils/const";
 import { waitForTransaction } from "./transaction";
 
@@ -20,14 +20,14 @@ export async function fundAccount(args: {
   accountAddress: AccountAddressInput;
   amount: number;
   options?: WaitForTransactionOptions;
-}): Promise<string> {
+}): Promise<UserTransactionResponse> {
   const { aptosConfig, accountAddress, amount, options } = args;
   const timeout = options?.timeoutSecs || DEFAULT_TXN_TIMEOUT_SEC;
   const { data } = await postAptosFaucet<any, { txn_hashes: Array<string> }>({
     aptosConfig,
     path: "fund",
     body: {
-      address: AccountAddress.fromRelaxed(accountAddress).toString(),
+      address: AccountAddress.from(accountAddress).toString(),
       amount,
     },
     originMethod: "fundAccount",
@@ -35,15 +35,19 @@ export async function fundAccount(args: {
 
   const txnHash = data.txn_hashes[0];
 
-  await waitForTransaction({
+  const res = await waitForTransaction({
     aptosConfig,
     transactionHash: txnHash,
     options: {
       timeoutSecs: timeout,
       checkSuccess: options?.checkSuccess,
-      indexerVersionCheck: options?.indexerVersionCheck,
     },
   });
 
-  return txnHash;
+  // Response is always User transaction for a user submitted transaction
+  if (res.type === TransactionResponseType.User) {
+    return res;
+  }
+
+  throw new Error(`Unexpected transaction received for fund account: ${res.type}`);
 }

package/src/internal/fungibleAsset.ts

@@ -10,10 +10,12 @@
 
 import { AptosConfig } from "../api/aptosConfig";
 import {
+  AnyNumber,
   GetCurrentFungibleAssetBalancesResponse,
   GetFungibleAssetActivitiesResponse,
   GetFungibleAssetMetadataResponse,
   PaginationArgs,
+  WhereArg,
 } from "../types";
 import { queryIndexer } from "./general";
 import {
@@ -31,13 +33,13 @@ import {
   FungibleAssetActivitiesBoolExp,
   FungibleAssetMetadataBoolExp,
 } from "../types/generated/types";
+import { Account, AccountAddress } from "../core";
+import { InputGenerateTransactionOptions } from "../transactions";
+import { generateTransaction } from "./transactionSubmission";
 
 export async function getFungibleAssetMetadata(args: {
   aptosConfig: AptosConfig;
-  options?: {
-    pagination?: PaginationArgs;
-    where?: FungibleAssetMetadataBoolExp;
-  };
+  options?: PaginationArgs & WhereArg<FungibleAssetMetadataBoolExp>;
 }): Promise<GetFungibleAssetMetadataResponse> {
   const { aptosConfig, options } = args;
 
@@ -45,8 +47,8 @@ export async function getFungibleAssetMetadata(args: {
     query: GetFungibleAssetMetadata,
     variables: {
       where_condition: options?.where,
-      limit: options?.pagination?.limit,
-      offset: options?.pagination?.offset,
+      limit: options?.limit,
+      offset: options?.offset,
     },
   };
 
@@ -61,10 +63,7 @@ export async function getFungibleAssetMetadata(args: {
 
 export async function getFungibleAssetActivities(args: {
   aptosConfig: AptosConfig;
-  options?: {
-    pagination?: PaginationArgs;
-    where?: FungibleAssetActivitiesBoolExp;
-  };
+  options?: PaginationArgs & WhereArg<FungibleAssetActivitiesBoolExp>;
 }): Promise<GetFungibleAssetActivitiesResponse> {
   const { aptosConfig, options } = args;
 
@@ -72,8 +71,8 @@ export async function getFungibleAssetActivities(args: {
     query: GetFungibleAssetActivities,
     variables: {
       where_condition: options?.where,
-      limit: options?.pagination?.limit,
-      offset: options?.pagination?.offset,
+      limit: options?.limit,
+      offset: options?.offset,
     },
   };
 
@@ -88,10 +87,7 @@ export async function getFungibleAssetActivities(args: {
 
 export async function getCurrentFungibleAssetBalances(args: {
   aptosConfig: AptosConfig;
-  options?: {
-    pagination?: PaginationArgs;
-    where?: CurrentFungibleAssetBalancesBoolExp;
-  };
+  options?: PaginationArgs & WhereArg<CurrentFungibleAssetBalancesBoolExp>;
 }): Promise<GetCurrentFungibleAssetBalancesResponse> {
   const { aptosConfig, options } = args;
 
@@ -99,8 +95,8 @@ export async function getCurrentFungibleAssetBalances(args: {
     query: GetCurrentFungibleAssetBalances,
     variables: {
       where_condition: options?.where,
-      limit: options?.pagination?.limit,
-      offset: options?.pagination?.offset,
+      limit: options?.limit,
+      offset: options?.offset,
     },
   };
 
@@ -112,3 +108,25 @@ export async function getCurrentFungibleAssetBalances(args: {
 
   return data.current_fungible_asset_balances;
 }
+
+export async function transferFungibleAsset(args: {
+  aptosConfig: AptosConfig;
+  sender: Account;
+  fungibleAssetMetadataAddress: AccountAddress;
+  recipient: AccountAddress;
+  amount: AnyNumber;
+  options?: InputGenerateTransactionOptions;
+}) {
+  const { aptosConfig, sender, fungibleAssetMetadataAddress, recipient, amount, options } = args;
+  const transaction = await generateTransaction({
+    aptosConfig,
+    sender: sender.accountAddress,
+    data: {
+      function: "0x1::primary_fungible_store::transfer",
+      typeArguments: ["0x1::fungible_asset::Metadata"],
+      functionArguments: [fungibleAssetMetadataAddress, recipient, amount],
+    },
+    options,
+  });
+  return transaction;
+}

package/src/internal/general.ts

@@ -17,7 +17,7 @@ import {
   GetProcessorStatusResponse,
   GraphqlQuery,
   LedgerInfo,
-  LedgerVersion,
+  LedgerVersionArg,
   MoveValue,
   TableItemRequest,
   ViewRequest,
@@ -25,6 +25,7 @@ import {
 } from "../types";
 import { GetChainTopUserTransactionsQuery, GetProcessorStatusQuery } from "../types/generated/operations";
 import { GetChainTopUserTransactions, GetProcessorStatus } from "../types/generated/queries";
+import { ProcessorType } from "../utils/const";
 
 export async function getLedgerInfo(args: { aptosConfig: AptosConfig }): Promise<LedgerInfo> {
   const { aptosConfig } = args;
@@ -70,7 +71,7 @@ export async function getTableItem<T>(args: {
   aptosConfig: AptosConfig;
   handle: string;
   data: TableItemRequest;
-  options?: LedgerVersion;
+  options?: LedgerVersionArg;
 }): Promise<T> {
   const { aptosConfig, handle, data, options } = args;
   const response = await postAptosFullNode<TableItemRequest, any>({
@@ -86,7 +87,7 @@ export async function getTableItem<T>(args: {
 export async function view<T extends Array<MoveValue> = Array<MoveValue>>(args: {
   aptosConfig: AptosConfig;
   payload: InputViewRequestData;
-  options?: LedgerVersion;
+  options?: LedgerVersionArg;
 }): Promise<T> {
   const { aptosConfig, payload, options } = args;
   const { data } = await postAptosFullNode<ViewRequest, MoveValue[]>({
@@ -159,3 +160,29 @@ export async function getIndexerLastSuccessVersion(args: { aptosConfig: AptosCon
   const response = await getProcessorStatuses({ aptosConfig: args.aptosConfig });
   return response[0].last_success_version;
 }
+
+export async function getProcessorStatus(args: {
+  aptosConfig: AptosConfig;
+  processorType: ProcessorType;
+}): Promise<GetProcessorStatusResponse[0]> {
+  const { aptosConfig, processorType } = args;
+
+  const whereCondition: { processor: { _eq: string } } = {
+    processor: { _eq: processorType.valueOf() },
+  };
+
+  const graphqlQuery = {
+    query: GetProcessorStatus,
+    variables: {
+      where_condition: whereCondition,
+    },
+  };
+
+  const data = await queryIndexer<GetProcessorStatusQuery>({
+    aptosConfig,
+    query: graphqlQuery,
+    originMethod: "getProcessorStatus",
+  });
+
+  return data.processor_status[0];
+}

package/src/internal/queries/ansTokenFragment.graphql

@@ -0,0 +1,9 @@
+fragment AnsTokenFragment on current_aptos_names {
+  domain
+  expiration_timestamp
+  registered_address
+  subdomain
+  token_standard
+  is_primary
+  owner_address
+}

package/src/internal/queries/getNames.graphql

@@ -0,0 +1,11 @@
+#import "./AnsTokenFragment";
+query getNames(
+  $offset: Int
+  $limit: Int
+  $where_condition: current_aptos_names_bool_exp
+  $order_by: [current_aptos_names_order_by!]
+) {
+  current_aptos_names(limit: $limit, where: $where_condition, order_by: $order_by, offset: $offset) {
+    ...AnsTokenFragment
+  }
+}

package/src/internal/queries/getNumberOfDelegatorsQuery.graphql

@@ -1,8 +1,8 @@
-query getNumberOfDelegators($where_condition: num_active_delegator_per_pool_bool_exp!, $order_by: [num_active_delegator_per_pool_order_by!]) {
-  num_active_delegator_per_pool(
-    where: $where_condition,
-    order_by: $order_by
-  ) {
+query getNumberOfDelegators(
+  $where_condition: num_active_delegator_per_pool_bool_exp
+  $order_by: [num_active_delegator_per_pool_order_by!]
+) {
+  num_active_delegator_per_pool(where: $where_condition, order_by: $order_by) {
     num_active_delegator
     pool_address
   }

package/src/internal/queries/getProcessorStatus.graphql

@@ -1,5 +1,5 @@
-query getProcessorStatus {
-  processor_status {
+query getProcessorStatus($where_condition: processor_status_bool_exp) {
+  processor_status(where: $where_condition) {
     last_success_version
     processor
     last_updated

package/src/internal/staking.ts

@@ -10,7 +10,7 @@
 
 import { AptosConfig } from "../api/aptosConfig";
 import { AccountAddress, AccountAddressInput } from "../core";
-import { GetDelegatedStakingActivitiesResponse, GetNumberOfDelegatorsResponse, OrderBy } from "../types";
+import { GetDelegatedStakingActivitiesResponse, GetNumberOfDelegatorsResponse, OrderByArg } from "../types";
 import { GetDelegatedStakingActivitiesQuery, GetNumberOfDelegatorsQuery } from "../types/generated/operations";
 import { GetDelegatedStakingActivities, GetNumberOfDelegators } from "../types/generated/queries";
 import { queryIndexer } from "./general";
@@ -20,30 +20,28 @@ export async function getNumberOfDelegators(args: {
   poolAddress: AccountAddressInput;
 }): Promise<number> {
   const { aptosConfig, poolAddress } = args;
-  const address = AccountAddress.fromRelaxed(poolAddress).toStringLong();
+  const address = AccountAddress.from(poolAddress).toStringLong();
   const query = {
     query: GetNumberOfDelegators,
     variables: { where_condition: { pool_address: { _eq: address } } },
   };
-  const data: GetNumberOfDelegatorsQuery = await queryIndexer<GetNumberOfDelegatorsQuery>({ aptosConfig, query });
-  if (data.num_active_delegator_per_pool.length === 0) {
-    throw Error("Delegator pool not found");
-  }
-  return data.num_active_delegator_per_pool[0].num_active_delegator;
+  const data = await queryIndexer<GetNumberOfDelegatorsQuery>({ aptosConfig, query });
+
+  // commonjs (aka cjs) doesnt handle Nullish Coalescing for some reason
+  // might be because of how ts infer the graphql generated scheme type
+  return data.num_active_delegator_per_pool[0] ? data.num_active_delegator_per_pool[0].num_active_delegator : 0;
 }
 
 export async function getNumberOfDelegatorsForAllPools(args: {
   aptosConfig: AptosConfig;
-  options?: {
-    orderBy?: OrderBy<GetNumberOfDelegatorsResponse[0]>;
-  };
+  options?: OrderByArg<GetNumberOfDelegatorsResponse[0]>;
 }): Promise<GetNumberOfDelegatorsResponse> {
   const { aptosConfig, options } = args;
   const query = {
     query: GetNumberOfDelegators,
-    variables: { where_condition: {}, order_by: options?.orderBy },
+    variables: { order_by: options?.orderBy },
   };
-  const data: GetNumberOfDelegatorsQuery = await queryIndexer<GetNumberOfDelegatorsQuery>({
+  const data = await queryIndexer<GetNumberOfDelegatorsQuery>({
     aptosConfig,
     query,
   });
@@ -59,8 +57,8 @@ export async function getDelegatedStakingActivities(args: {
   const query = {
     query: GetDelegatedStakingActivities,
     variables: {
-      delegatorAddress: AccountAddress.fromRelaxed(delegatorAddress).toStringLong(),
-      poolAddress: AccountAddress.fromRelaxed(poolAddress).toStringLong(),
+      delegatorAddress: AccountAddress.from(delegatorAddress).toStringLong(),
+      poolAddress: AccountAddress.from(poolAddress).toStringLong(),
     },
   };
   const data = await queryIndexer<GetDelegatedStakingActivitiesQuery>({ aptosConfig, query });

package/src/internal/transaction.ts

@@ -18,11 +18,12 @@ import {
   type PaginationArgs,
   type TransactionResponse,
   WaitForTransactionOptions,
+  CommittedTransactionResponse,
 } from "../types";
-import { DEFAULT_TXN_TIMEOUT_SEC } from "../utils/const";
+import { DEFAULT_TXN_TIMEOUT_SEC, ProcessorType } from "../utils/const";
 import { sleep } from "../utils/helpers";
 import { memoizeAsync } from "../utils/memoize";
-import { getIndexerLastSuccessVersion } from "./general";
+import { getIndexerLastSuccessVersion, getProcessorStatus } from "./general";
 
 export async function getTransactions(args: {
   aptosConfig: AptosConfig;
@@ -100,11 +101,10 @@ export async function waitForTransaction(args: {
   aptosConfig: AptosConfig;
   transactionHash: HexInput;
   options?: WaitForTransactionOptions;
-}): Promise<TransactionResponse> {
+}): Promise<CommittedTransactionResponse> {
   const { aptosConfig, transactionHash, options } = args;
   const timeoutSecs = options?.timeoutSecs ?? DEFAULT_TXN_TIMEOUT_SEC;
   const checkSuccess = options?.checkSuccess ?? true;
-  const indexerVersionCheck = options?.indexerVersionCheck ?? true;
 
   let isPending = true;
   let timeElapsed = 0;
@@ -167,49 +167,46 @@ export async function waitForTransaction(args: {
   }
   if (!lastTxn.success) {
     throw new FailedTransactionError(
-      `Transaction ${transactionHash} failed with an error: ${(lastTxn as any).vm_status}`,
+      `Transaction ${transactionHash} failed with an error: ${lastTxn.vm_status}`,
       lastTxn,
     );
   }
 
-  // Make sure indexer is synced with the latest ledger version
-  if (indexerVersionCheck) {
-    try {
-      await waitForLastSuccessIndexerVersionSync({ aptosConfig, ledgerVersion: Number(lastTxn.version) });
-    } catch (_e) {
-      throw new WaitForTransactionError(
-        // eslint-disable-next-line max-len
-        `Transaction ${transactionHash} committed, but timed out waiting for indexer to sync with ledger version ${lastTxn.version}.` +
-          "You can disable this check by setting `indexerVersionCheck` to false in the `extraArgs` parameter.",
-        lastTxn,
-      );
-    }
-  }
-
   return lastTxn;
 }
 
 /**
  * Waits for the indexer to sync up to the ledgerVersion. Timeout is 3 seconds.
  */
-async function waitForLastSuccessIndexerVersionSync(args: {
+export async function waitForIndexer(args: {
   aptosConfig: AptosConfig;
-  ledgerVersion: number;
+  minimumLedgerVersion: AnyNumber;
+  processorType?: ProcessorType;
 }): Promise<void> {
-  const { aptosConfig, ledgerVersion } = args;
+  const { aptosConfig, processorType } = args;
+  const minimumLedgerVersion = BigInt(args.minimumLedgerVersion);
   const timeoutMilliseconds = 3000; // 3 seconds
   const startTime = new Date().getTime();
   let indexerVersion = -1;
 
-  while (indexerVersion < ledgerVersion) {
+  while (indexerVersion < minimumLedgerVersion) {
     // check for timeout
     if (new Date().getTime() - startTime > timeoutMilliseconds) {
       throw new Error("waitForLastSuccessIndexerVersionSync timeout");
     }
 
-    // eslint-disable-next-line no-await-in-loop
-    indexerVersion = await getIndexerLastSuccessVersion({ aptosConfig });
-    if (indexerVersion >= ledgerVersion) {
+    if (processorType === undefined) {
+      // Get the last success version from all processor
+      // eslint-disable-next-line no-await-in-loop
+      indexerVersion = await getIndexerLastSuccessVersion({ aptosConfig });
+    } else {
+      // Get the last success version from the specific processor
+      // eslint-disable-next-line no-await-in-loop
+      const processor = await getProcessorStatus({ aptosConfig, processorType });
+      indexerVersion = processor.last_success_version;
+    }
+
+    if (indexerVersion >= minimumLedgerVersion) {
       // break out immediately if we are synced
       break;
     }

package/src/internal/transactionSubmission.ts

@@ -19,21 +19,36 @@ import {
   generateSignedTransactionForSimulation,
   generateSignedTransaction,
   sign,
+  generateSigningMessage,
 } from "../transactions/transactionBuilder/transactionBuilder";
 import {
   InputGenerateTransactionData,
   AnyRawTransaction,
   InputSimulateTransactionData,
   InputGenerateTransactionOptions,
-  InputSingleSignerTransaction,
+  SingleSignerTransaction,
   InputGenerateTransactionPayloadDataWithRemoteABI,
   InputSubmitTransactionData,
-  InputGenerateFeePayerRawTransactionData,
   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
  *
@@ -77,12 +92,21 @@ import { UserTransactionResponse, PendingTransactionResponse, MimeType, HexInput
 export async function generateTransaction(
   args: { aptosConfig: AptosConfig } & InputGenerateTransactionData,
 ): Promise<AnyRawTransaction> {
-  const { aptosConfig, sender, data, options } = args;
+  const payload = await buildTransactionPayload(args);
+  return buildRawTransaction(args, payload);
+}
+
+export async function buildTransactionPayload(
+  args: { aptosConfig: AptosConfig } & InputGenerateTransactionData,
+): Promise<AnyTransactionPayloadInstance> {
+  const { aptosConfig, data } = 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,
@@ -91,6 +115,7 @@ export async function generateTransaction(
       functionArguments: data.functionArguments,
       typeArguments: data.typeArguments,
     };
+    payload = await generateTransactionPayload(generateTransactionPayloadData);
   } else {
     generateTransactionPayloadData = {
       aptosConfig,
@@ -98,46 +123,45 @@ export async function generateTransaction(
       functionArguments: data.functionArguments,
       typeArguments: data.typeArguments,
     };
+    payload = await generateTransactionPayload(generateTransactionPayloadData);
   }
+  return payload;
+}
 
+export async function buildRawTransaction(
+  args: { aptosConfig: AptosConfig } & InputGenerateTransactionData,
+  payload: AnyTransactionPayloadInstance,
+): Promise<AnyRawTransaction> {
+  const { aptosConfig, sender, options } = args;
+
+  let feePayerAddress;
   if (isFeePayerTransactionInput(args)) {
-    const { secondarySignerAddresses } = args;
-    const feePayerAddress = args.hasFeePayer ? AccountAddress.ZERO : undefined;
-    const payload = await generateTransactionPayload(generateTransactionPayloadData);
-    return buildTransaction({
-      aptosConfig,
-      sender,
-      payload,
-      options,
-      secondarySignerAddresses,
-      feePayerAddress,
-    });
+    feePayerAddress = AccountAddress.ZERO.toString();
   }
+
   if (isMultiAgentTransactionInput(args)) {
     const { secondarySignerAddresses } = args;
-    const payload = await generateTransactionPayload(generateTransactionPayloadData);
     return buildTransaction({
       aptosConfig,
       sender,
       payload,
       options,
       secondarySignerAddresses,
+      feePayerAddress,
     });
   }
 
-  const payload = await generateTransactionPayload(generateTransactionPayloadData);
   return buildTransaction({
     aptosConfig,
     sender,
     payload,
     options,
+    feePayerAddress,
   });
 }
 
-function isFeePayerTransactionInput(
-  data: InputGenerateTransactionData,
-): data is InputGenerateFeePayerRawTransactionData {
-  return "hasFeePayer" in data;
+function isFeePayerTransactionInput(data: InputGenerateTransactionData): boolean {
+  return data.withFeePayer === true;
 }
 
 function isMultiAgentTransactionInput(
@@ -146,6 +170,20 @@ function isMultiAgentTransactionInput(
   return "secondarySignerAddresses" in data;
 }
 
+/**
+ * Builds a signing message that can be signed by external signers
+ *
+ * Note: Please prefer using `signTransaction` unless signing outside the SDK
+ *
+ * @param args.transaction AnyRawTransaction, as generated by `generateTransaction()`
+ *
+ * @return The message to be signed
+ */
+export function getSigningMessage(args: { transaction: AnyRawTransaction }): Uint8Array {
+  const { transaction } = args;
+  return generateSigningMessage(transaction);
+}
+
 /**
  * Sign a transaction that can later be submitted to chain
  *
@@ -249,21 +287,21 @@ 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));
 
   const transaction = await generateTransaction({
     aptosConfig,
-    sender: AccountAddress.fromRelaxed(account),
+    sender: AccountAddress.from(account),
     data: {
       function: "0x1::code::publish_package_txn",
       functionArguments: [MoveVector.U8(metadataBytes), new MoveVector(totalByteCode)],
     },
     options,
   });
-  return transaction as InputSingleSignerTransaction;
+  return transaction;
 }
 
 /**
@@ -277,7 +315,7 @@ export async function rotateAuthKey(args: {
   const { aptosConfig, fromAccount, toNewPrivateKey } = args;
   const accountInfo = await getInfo({
     aptosConfig,
-    accountAddress: fromAccount.accountAddress.toString(),
+    accountAddress: fromAccount.accountAddress,
   });
 
   const newAccount = Account.fromPrivateKey({ privateKey: toNewPrivateKey, legacy: true });
@@ -297,7 +335,7 @@ export async function rotateAuthKey(args: {
   // Generate transaction
   const rawTxn = await generateTransaction({
     aptosConfig,
-    sender: fromAccount.accountAddress.toString(),
+    sender: fromAccount.accountAddress,
     data: {
       function: "0x1::account::rotate_authentication_key",
       functionArguments: [