@aptos-labs/ts-sdk 0.0.6 → 0.0.7

package/src/api/transactionSubmission.ts

@@ -3,30 +3,9 @@
 
 import { AptosConfig } from "./aptosConfig";
 import { Account, AccountAddressInput, PrivateKey } from "../core";
-import { AccountAuthenticator } from "../transactions/authenticator/account";
-import {
-  AnyRawTransaction,
-  InputFeePayerTransaction,
-  InputGenerateMultiAgentRawTransactionData,
-  InputGenerateTransactionData,
-  InputGenerateFeePayerRawTransactionData,
-  InputGenerateSingleSignerRawTransactionData,
-  InputMultiAgentTransaction,
-  InputSingleSignerTransaction,
-  InputSimulateTransactionData,
-  InputGenerateTransactionOptions,
-  InputSubmitTransactionData,
-} from "../transactions/types";
-import { UserTransactionResponse, PendingTransactionResponse, HexInput, TransactionResponse } from "../types";
-import {
-  generateTransaction,
-  publicPackageTransaction,
-  rotateAuthKey,
-  signAndSubmitTransaction,
-  signTransaction,
-  simulateTransaction,
-  submitTransaction,
-} from "../internal/transactionSubmission";
+import { AnyRawTransaction, SingleSignerTransaction, InputGenerateTransactionOptions } from "../transactions/types";
+import { PendingTransactionResponse, HexInput, TransactionResponse } from "../types";
+import { publicPackageTransaction, rotateAuthKey, signAndSubmitTransaction } from "../internal/transactionSubmission";
 
 export class TransactionSubmission {
   readonly config: AptosConfig;
@@ -35,124 +14,6 @@ export class TransactionSubmission {
     this.config = config;
   }
 
-  /**
-   * 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.
-   */
-  async generateTransaction(args: InputGenerateSingleSignerRawTransactionData): Promise<InputSingleSignerTransaction>;
-  async generateTransaction(args: InputGenerateFeePayerRawTransactionData): Promise<InputFeePayerTransaction>;
-  async generateTransaction(args: InputGenerateMultiAgentRawTransactionData): Promise<InputMultiAgentTransaction>;
-  async generateTransaction(args: InputGenerateTransactionData): Promise<AnyRawTransaction>;
-
-  /**
-   * Generates any transaction by passing in the required arguments
-   *
-   * @param args.sender The transaction sender's account address as a AccountAddressInput
-   * @param args.data EntryFunctionData | ScriptData | MultiSigData
-   * @param args.feePayerAddress optional. For a fee payer (aka sponsored) transaction
-   * @param args.secondarySignerAddresses optional. For a multi-agent or fee payer (aka sponsored) transactions
-   * @param args.options optional. GenerateTransactionOptions type
-   *
-   * @example
-   * For a single signer entry function
-   * move function name, move function type arguments, move function arguments
-   * `
-   * data: {
-   *  function: "0x1::aptos_account::transfer",
-   *  typeArguments: []
-   *  functionArguments: [receiverAddress,10]
-   * }
-   * `
-   *
-   * @example
-   * For a single signer script function
-   * module bytecode, move function type arguments, move function arguments
-   * ```
-   * data: {
-   *  bytecode: "0x001234567",
-   *  typeArguments: [],
-   *  functionArguments: [receiverAddress,10]
-   * }
-   * ```
-   *
-   * @return An instance of a RawTransaction, plus optional secondary/fee payer addresses
-   * ```
-   * {
-   *  rawTransaction: RawTransaction,
-   *  secondarySignerAddresses? : Array<AccountAddress>,
-   *  feePayerAddress?: AccountAddress
-   * }
-   * ```
-   */
-  async generateTransaction(args: InputGenerateTransactionData): Promise<AnyRawTransaction> {
-    return generateTransaction({ aptosConfig: this.config, ...args });
-  }
-
-  /**
-   * Sign a transaction that can later be submitted to chain
-   *
-   * @param args.signer The signer account to sign the transaction
-   * @param args.transaction An instance of a RawTransaction, plus optional secondary/fee payer addresses
-   * @param args.asFeePayer optional. If the signer is also the fee payer
-   * ```
-   * {
-   *  rawTransaction: RawTransaction,
-   *  secondarySignerAddresses?: Array<AccountAddress>,
-   *  feePayerAddress?: AccountAddress
-   * }
-   * ```
-   *
-   * @return The signer AccountAuthenticator
-   */
-  /* eslint-disable class-methods-use-this */
-  signTransaction(args: {
-    signer: Account;
-    transaction: AnyRawTransaction;
-    asFeePayer?: boolean;
-  }): AccountAuthenticator {
-    const { signer, transaction, asFeePayer } = args;
-
-    // Account can only sign as fee payer if it's a fee payer transaction
-    if ("feePayerAddress" in transaction && asFeePayer) {
-      transaction.feePayerAddress = signer.accountAddress;
-    } else if (asFeePayer) {
-      throw new Error("Transaction being signed is not a Fee payer transaction, but `asFeePayer` is set to true");
-    }
-
-    return signTransaction({
-      signer,
-      transaction,
-    });
-  }
-
-  /**
-   * Simulates a transaction before singing it.
-   *
-   * @param args.signerPublicKey The signer public key
-   * @param args.transaction The raw transaction to simulate
-   * @param args.secondarySignersPublicKeys optional. For when the transaction is a multi signers transaction
-   * @param args.feePayerPublicKey optional. For when the transaction is a fee payer (aka sponsored) transaction
-   * @param args.options optional. A config to simulate the transaction with
-   */
-  async simulateTransaction(args: InputSimulateTransactionData): Promise<Array<UserTransactionResponse>> {
-    return simulateTransaction({ aptosConfig: this.config, ...args });
-  }
-
-  /**
-   * Submit transaction to chain
-   *
-   * @param args.transaction A aptos transaction type
-   * @param args.senderAuthenticator The account authenticator of the transaction sender
-   * @param args.secondarySignerAuthenticators optional. For when the transaction is a multi signers transaction
-   *
-   * @return PendingTransactionResponse
-   */
-  async submitTransaction(args: InputSubmitTransactionData): Promise<PendingTransactionResponse> {
-    return submitTransaction({ aptosConfig: this.config, ...args });
-  }
-
   /**
    * Sign and submit a single signer transaction to chain
    *
@@ -198,7 +59,7 @@ export class TransactionSubmission {
     metadataBytes: HexInput;
     moduleBytecode: Array<HexInput>;
     options?: InputGenerateTransactionOptions;
-  }): Promise<InputSingleSignerTransaction> {
+  }): Promise<SingleSignerTransaction> {
     return publicPackageTransaction({ aptosConfig: this.config, ...args });
   }
 

package/src/internal/ans.ts

@@ -9,12 +9,14 @@
  */
 
 import { AptosConfig } from "../api/aptosConfig";
-import { MoveOption, MoveString, U64 } from "../bcs";
-import { Account, AccountAddress } from "../core";
-import { InputGenerateTransactionOptions, InputSingleSignerTransaction } from "../transactions/types";
-import { HexInput, MoveAddressType, MoveValue } from "../types";
+import { Account, AccountAddress, AccountAddressInput } from "../core";
+import { InputGenerateTransactionOptions, SingleSignerTransaction } from "../transactions/types";
+import { GetANSNameResponse, MoveAddressType, MoveValue, OrderBy, PaginationArgs } from "../types";
+import { GetNamesQuery } from "../types/generated/operations";
+import { GetNames } from "../types/generated/queries";
+import { CurrentAptosNamesBoolExp } from "../types/generated/types";
 import { Network } from "../utils/apiEndpoints";
-import { view } from "./general";
+import { queryIndexer, view } from "./general";
 import { generateTransaction } from "./transactionSubmission";
 
 export const VALIDATION_RULES_DESCRIPTION = [
@@ -119,17 +121,17 @@ export interface RegisterNameParameters {
   sender: Account;
   name: string;
   expiration:
-    | { policy: "domain"; years: 1 }
+    | { policy: "domain"; years?: 1 }
     | { policy: "subdomain:follow-domain" }
     | { policy: "subdomain:independent"; expirationDate: Date };
   transferable?: boolean;
-  toAddress?: HexInput;
-  targetAddress?: HexInput;
+  toAddress?: AccountAddressInput;
+  targetAddress?: AccountAddressInput;
   options?: InputGenerateTransactionOptions;
 }
 
-export async function registerName(args: RegisterNameParameters): Promise<InputSingleSignerTransaction> {
-  const { aptosConfig, expiration, name, sender, targetAddress, toAddress, options } = args;
+export async function registerName(args: RegisterNameParameters): Promise<SingleSignerTransaction> {
+  const { aptosConfig, expiration, name, sender, targetAddress, toAddress, options, transferable } = args;
   const routerAddress = getRouterAddress(aptosConfig);
   const { domainName, subdomainName } = isValidANSName(name);
 
@@ -147,29 +149,413 @@ export async function registerName(args: RegisterNameParameters): Promise<InputS
   }
 
   if (expiration.policy === "domain") {
-    if (expiration.years !== 1) {
+    const years = expiration.years ?? 1;
+    if (years !== 1) {
       throw new Error("For now, names can only be registered for 1 year at a time");
     }
 
-    const registrationDuration = expiration.years * 31536000;
+    const secondsInYear = 31536000;
+    const registrationDuration = years * secondsInYear;
 
     const transaction = await generateTransaction({
       aptosConfig,
       sender: sender.accountAddress.toString(),
       data: {
         function: `${routerAddress}::router::register_domain`,
-        functionArguments: [
-          new MoveString(domainName),
-          new U64(registrationDuration),
-          new MoveOption(targetAddress ? AccountAddress.from(targetAddress) : null),
-          new MoveOption(toAddress ? AccountAddress.from(toAddress) : null),
-        ],
+        functionArguments: [domainName, registrationDuration, targetAddress, toAddress],
       },
       options,
     });
 
-    return transaction as InputSingleSignerTransaction;
+    return transaction as SingleSignerTransaction;
   }
 
-  throw new Error(`Policy ${expiration.policy} is not supported yet`);
+  // We are a subdomain
+  if (!subdomainName) {
+    throw new Error(`${expiration.policy} requires a subdomain to be provided.`);
+  }
+
+  let tldExpiration = await getExpiration({ aptosConfig, name: domainName });
+  if (!tldExpiration) {
+    throw new Error("The domain does not exist");
+  }
+  // The contract gives us seconds, but JS expects milliseconds
+  tldExpiration *= 1000;
+
+  const expirationDateInMillisecondsSinceEpoch =
+    expiration.policy === "subdomain:independent" ? expiration.expirationDate.valueOf() : tldExpiration;
+
+  if (expirationDateInMillisecondsSinceEpoch > tldExpiration) {
+    throw new Error("The subdomain expiration time cannot be greater than the domain expiration time");
+  }
+
+  const transaction = await generateTransaction({
+    aptosConfig,
+    sender: sender.accountAddress.toString(),
+    data: {
+      function: `${routerAddress}::router::register_subdomain`,
+      functionArguments: [
+        domainName,
+        subdomainName,
+        Math.round(expirationDateInMillisecondsSinceEpoch / 1000),
+        expiration.policy === "subdomain:follow-domain" ? 1 : 0,
+        !!transferable,
+        targetAddress,
+        toAddress,
+      ],
+    },
+    options,
+  });
+
+  return transaction as SingleSignerTransaction;
+}
+
+export async function getExpiration(args: { aptosConfig: AptosConfig; name: string }): Promise<number | undefined> {
+  const { aptosConfig, name } = args;
+  const routerAddress = getRouterAddress(aptosConfig);
+  const { domainName, subdomainName } = isValidANSName(name);
+
+  try {
+    const res = await view({
+      aptosConfig,
+      payload: {
+        function: `${routerAddress}::router::get_expiration`,
+        functionArguments: [domainName, Option(subdomainName)],
+      },
+    });
+
+    return res[0] as number;
+  } catch (e) {
+    return undefined;
+  }
+}
+
+export async function getPrimaryName(args: {
+  aptosConfig: AptosConfig;
+  address: AccountAddressInput;
+}): Promise<string | undefined> {
+  const { aptosConfig, address } = args;
+  const routerAddress = getRouterAddress(aptosConfig);
+
+  const res = await view({
+    aptosConfig,
+    payload: {
+      function: `${routerAddress}::router::get_primary_name`,
+      functionArguments: [AccountAddress.fromRelaxed(address).toString()],
+    },
+  });
+
+  const domainName = unwrapOption<MoveAddressType>(res[1]);
+  const subdomainName = unwrapOption<MoveAddressType>(res[0]);
+
+  if (!domainName) return undefined;
+
+  return [subdomainName, domainName].filter(Boolean).join(".");
+}
+
+export async function setPrimaryName(args: {
+  aptosConfig: AptosConfig;
+  sender: Account;
+  name: string | null;
+  options?: InputGenerateTransactionOptions;
+}): Promise<SingleSignerTransaction> {
+  const { aptosConfig, sender, name, options } = args;
+  const routerAddress = getRouterAddress(aptosConfig);
+
+  if (!name) {
+    const transaction = await generateTransaction({
+      aptosConfig,
+      sender: sender.accountAddress.toString(),
+      data: {
+        function: `${routerAddress}::router::clear_primary_name`,
+        functionArguments: [],
+      },
+      options,
+    });
+
+    return transaction as SingleSignerTransaction;
+  }
+
+  const { domainName, subdomainName } = isValidANSName(name);
+
+  const transaction = await generateTransaction({
+    aptosConfig,
+    sender: sender.accountAddress.toString(),
+    data: {
+      function: `${routerAddress}::router::set_primary_name`,
+      functionArguments: [domainName, subdomainName],
+    },
+    options,
+  });
+
+  return transaction as SingleSignerTransaction;
+}
+
+export async function getTargetAddress(args: {
+  aptosConfig: AptosConfig;
+  name: string;
+}): Promise<MoveAddressType | undefined> {
+  const { aptosConfig, name } = args;
+  const routerAddress = getRouterAddress(aptosConfig);
+  const { domainName, subdomainName } = isValidANSName(name);
+
+  const res = await view({
+    aptosConfig,
+    payload: {
+      function: `${routerAddress}::router::get_target_addr`,
+      functionArguments: [domainName, Option(subdomainName)],
+    },
+  });
+
+  const target = unwrapOption<MoveAddressType>(res[0]);
+  return target ? AccountAddress.fromRelaxed(target).toString() : undefined;
+}
+
+export async function setTargetAddress(args: {
+  aptosConfig: AptosConfig;
+  sender: Account;
+  name: string;
+  address: AccountAddressInput;
+  options?: InputGenerateTransactionOptions;
+}): Promise<SingleSignerTransaction> {
+  const { aptosConfig, sender, name, address, options } = args;
+  const routerAddress = getRouterAddress(aptosConfig);
+  const { domainName, subdomainName } = isValidANSName(name);
+
+  const transaction = await generateTransaction({
+    aptosConfig,
+    sender: sender.accountAddress.toString(),
+    data: {
+      function: `${routerAddress}::router::set_target_addr`,
+      functionArguments: [domainName, subdomainName, address],
+    },
+    options,
+  });
+
+  return transaction as SingleSignerTransaction;
+}
+
+export async function getName(args: {
+  aptosConfig: AptosConfig;
+  name: string;
+}): Promise<GetANSNameResponse[0] | undefined> {
+  const { aptosConfig, name } = args;
+  const { domainName, subdomainName = "" } = isValidANSName(name);
+
+  const where: CurrentAptosNamesBoolExp = {
+    domain: { _eq: domainName },
+    subdomain: { _eq: subdomainName },
+  };
+
+  const data = await queryIndexer<GetNamesQuery>({
+    aptosConfig,
+    query: {
+      query: GetNames,
+      variables: {
+        where_condition: where,
+        limit: 1,
+      },
+    },
+    originMethod: "getName",
+  });
+
+  return data.current_aptos_names[0] as GetANSNameResponse[0] | undefined;
+}
+
+interface QueryNamesOptions {
+  options?: {
+    pagination?: PaginationArgs;
+    orderBy?: OrderBy<GetANSNameResponse[0]>;
+    where?: CurrentAptosNamesBoolExp;
+  };
+}
+
+export interface GetAccountNamesArgs extends QueryNamesOptions {
+  accountAddress: AccountAddressInput;
+}
+
+export async function getAccountNames(
+  args: { aptosConfig: AptosConfig } & GetAccountNamesArgs,
+): Promise<GetANSNameResponse> {
+  const { aptosConfig, options, accountAddress } = args;
+
+  const expirationDate = await getANSExpirationDate({ aptosConfig });
+
+  const data = await queryIndexer<GetNamesQuery>({
+    aptosConfig,
+    originMethod: "getAccountNames",
+    query: {
+      query: GetNames,
+      variables: {
+        limit: options?.pagination?.limit,
+        offset: options?.pagination?.offset,
+        order_by: options?.orderBy,
+        where_condition: {
+          ...(args.options?.where ?? {}),
+          owner_address: { _eq: accountAddress.toString() },
+          expiration_timestamp: { _gte: expirationDate },
+        },
+      },
+    },
+  });
+
+  return data.current_aptos_names;
+}
+
+export interface GetAccountDomainsArgs extends QueryNamesOptions {
+  accountAddress: AccountAddressInput;
+}
+
+export async function getAccountDomains(
+  args: { aptosConfig: AptosConfig } & GetAccountDomainsArgs,
+): Promise<GetANSNameResponse> {
+  const { aptosConfig, options, accountAddress } = args;
+
+  const expirationDate = await getANSExpirationDate({ aptosConfig });
+
+  const data = await queryIndexer<GetNamesQuery>({
+    aptosConfig,
+    originMethod: "getAccountDomains",
+    query: {
+      query: GetNames,
+      variables: {
+        limit: options?.pagination?.limit,
+        offset: options?.pagination?.offset,
+        order_by: options?.orderBy,
+        where_condition: {
+          ...(args.options?.where ?? {}),
+          owner_address: { _eq: accountAddress.toString() },
+          expiration_timestamp: { _gte: expirationDate },
+          subdomain: { _eq: "" },
+        },
+      },
+    },
+  });
+
+  return data.current_aptos_names;
+}
+
+export interface GetAccountSubdomainsArgs extends QueryNamesOptions {
+  accountAddress: AccountAddressInput;
+}
+
+export async function getAccountSubdomains(
+  args: { aptosConfig: AptosConfig } & GetAccountSubdomainsArgs,
+): Promise<GetANSNameResponse> {
+  const { aptosConfig, options, accountAddress } = args;
+
+  const expirationDate = await getANSExpirationDate({ aptosConfig });
+
+  const data = await queryIndexer<GetNamesQuery>({
+    aptosConfig,
+    originMethod: "getAccountSubdomains",
+    query: {
+      query: GetNames,
+      variables: {
+        limit: options?.pagination?.limit,
+        offset: options?.pagination?.offset,
+        order_by: options?.orderBy,
+        where_condition: {
+          ...(args.options?.where ?? {}),
+          owner_address: { _eq: accountAddress.toString() },
+          expiration_timestamp: { _gte: expirationDate },
+          subdomain: { _neq: "" },
+        },
+      },
+    },
+  });
+
+  return data.current_aptos_names;
+}
+
+export interface GetDomainSubdomainsArgs extends QueryNamesOptions {
+  domain: string;
+}
+
+export async function getDomainSubdomains(
+  args: { aptosConfig: AptosConfig } & GetDomainSubdomainsArgs,
+): Promise<GetANSNameResponse> {
+  const { aptosConfig, options, domain } = args;
+
+  const data = await queryIndexer<GetNamesQuery>({
+    aptosConfig,
+    originMethod: "getDomainSubdomains",
+    query: {
+      query: GetNames,
+      variables: {
+        limit: options?.pagination?.limit,
+        offset: options?.pagination?.offset,
+        order_by: options?.orderBy,
+        where_condition: {
+          ...(args.options?.where ?? {}),
+          domain: { _eq: domain },
+          subdomain: { _neq: "" },
+        },
+      },
+    },
+  });
+
+  return data.current_aptos_names;
+}
+
+/**
+ * This function returns the expiration date in which a name is fully expired as
+ * defined by the contract.  The grace period allows for names to be past
+ * expiration for a certain amount of time before they are released to the
+ * public. The names will not function as normal, but the owner can renew
+ * without others taking ownership of the name. At the time of writing, the
+ * contract specified 30 days.
+ *
+ * @param args.aptosConfig an AptosConfig object
+ * @returns
+ */
+async function getANSExpirationDate(args: { aptosConfig: AptosConfig }): Promise<string> {
+  const { aptosConfig } = args;
+  const routerAddress = getRouterAddress(aptosConfig);
+
+  const res = await view({
+    aptosConfig,
+    payload: {
+      function: `${routerAddress}::config::reregistration_grace_sec`,
+      functionArguments: [],
+    },
+  });
+
+  const gracePeriodInSeconds = res[0] as number;
+  const gracePeriodInDays = gracePeriodInSeconds / 60 / 60 / 24;
+  const now = () => new Date();
+  return new Date(now().setDate(now().getDate() - gracePeriodInDays)).toISOString();
+}
+
+export async function renewDomain(args: {
+  aptosConfig: AptosConfig;
+  sender: Account;
+  name: string;
+  years?: 1;
+  options?: InputGenerateTransactionOptions;
+}): Promise<SingleSignerTransaction> {
+  const { aptosConfig, sender, name, years = 1, options } = args;
+  const routerAddress = getRouterAddress(aptosConfig);
+  const renewalDuration = years * 31536000;
+  const { domainName, subdomainName } = isValidANSName(name);
+
+  if (subdomainName) {
+    throw new Error("Subdomains cannot be renewed");
+  }
+
+  if (years !== 1) {
+    throw new Error("Currently, only 1 year renewals are supported");
+  }
+
+  const transaction = await generateTransaction({
+    aptosConfig,
+    sender: sender.accountAddress.toString(),
+    data: {
+      function: `${routerAddress}::router::renew_domain`,
+      functionArguments: [domainName, renewalDuration],
+    },
+    options,
+  });
+
+  return transaction as SingleSignerTransaction;
 }

package/src/internal/coin.ts

@@ -1,7 +1,7 @@
 import { AptosConfig } from "../api/aptosConfig";
 import { U64 } from "../bcs/serializable/movePrimitives";
 import { Account, AccountAddress, AccountAddressInput } from "../core";
-import { InputGenerateTransactionOptions, InputSingleSignerTransaction } from "../transactions/types";
+import { InputGenerateTransactionOptions, SingleSignerTransaction } from "../transactions/types";
 import { AnyNumber, MoveStructId } from "../types";
 import { APTOS_COIN } from "../utils/const";
 import { generateTransaction } from "./transactionSubmission";
@@ -14,7 +14,7 @@ export async function transferCoinTransaction(args: {
   amount: AnyNumber;
   coinType?: MoveStructId;
   options?: InputGenerateTransactionOptions;
-}): Promise<InputSingleSignerTransaction> {
+}): Promise<SingleSignerTransaction> {
   const { aptosConfig, sender, recipient, amount, coinType, options } = args;
   const coinStructType = coinType ?? APTOS_COIN;
   const transaction = await generateTransaction({
@@ -28,5 +28,5 @@ export async function transferCoinTransaction(args: {
     options,
   });
 
-  return transaction as InputSingleSignerTransaction;
+  return transaction as SingleSignerTransaction;
 }

package/src/internal/digitalAsset.ts

@@ -11,7 +11,7 @@
 import { AptosConfig } from "../api/aptosConfig";
 import { MoveString, MoveVector, Bool, U64, U8 } from "../bcs";
 import { Account, AccountAddress, AccountAddressInput } from "../core";
-import { InputGenerateTransactionOptions, InputSingleSignerTransaction } from "../transactions/types";
+import { InputGenerateTransactionOptions, SingleSignerTransaction } from "../transactions/types";
 import {
   AnyNumber,
   GetCollectionDataResponse,
@@ -55,7 +55,7 @@ export async function mintTokenTransaction(args: {
   name: string;
   uri: string;
   options?: InputGenerateTransactionOptions;
-}): Promise<InputSingleSignerTransaction> {
+}): Promise<SingleSignerTransaction> {
   const { aptosConfig, options, creator } = args;
   const transaction = await generateTransaction({
     aptosConfig,
@@ -74,7 +74,7 @@ export async function mintTokenTransaction(args: {
     },
     options,
   });
-  return transaction as InputSingleSignerTransaction;
+  return transaction as SingleSignerTransaction;
 }
 
 export async function getTokenData(args: {
@@ -219,7 +219,7 @@ export async function createCollectionTransaction(
     uri: string;
     options?: InputGenerateTransactionOptions;
   } & CreateCollectionOptions,
-): Promise<InputSingleSignerTransaction> {
+): Promise<SingleSignerTransaction> {
   const { aptosConfig, options, creator } = args;
   const transaction = await generateTransaction({
     aptosConfig,
@@ -247,7 +247,7 @@ export async function createCollectionTransaction(
     },
     options,
   });
-  return transaction as InputSingleSignerTransaction;
+  return transaction as SingleSignerTransaction;
 }
 
 export async function getCollectionData(args: {