@aptos-labs/ts-sdk 0.0.3 → 0.0.4

package/src/internal/ans.ts

@@ -0,0 +1,177 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * This file contains the underlying implementations for exposed API surface in
+ * the {@link api/name}. By moving the methods out into a separate file,
+ * other namespaces and processes can access these methods without depending on the entire
+ * name namespace and without having a dependency cycle error.
+ */
+
+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 { Network } from "../utils/apiEndpoints";
+import { view } from "./general";
+import { generateTransaction } from "./transactionSubmission";
+
+export const VALIDATION_RULES_DESCRIPTION = [
+  "A name must be between 3 and 63 characters long,",
+  "and can only contain lowercase a-z, 0-9, and hyphens.",
+  "A name may not start or end with a hyphen.",
+].join(" ");
+
+/**
+ *
+ * @param fragment A fragment of a name, either the domain or subdomain
+ * @returns boolean indicating if the fragment is a valid fragment
+ */
+export function isValidANSSegment(fragment: string): boolean {
+  if (!fragment) return false;
+  if (fragment.length < 3) return false;
+  if (fragment.length > 63) return false;
+  // only lowercase a-z and 0-9 are allowed, along with -. a domain may not start or end with a hyphen
+  if (!/^[a-z\d][a-z\d-]{1,61}[a-z\d]$/.test(fragment)) return false;
+  return true;
+}
+
+/**
+ * Checks if an ANS name is valid or not
+ *
+ * @param name A string of the domain name, can include or exclude the .apt suffix
+ */
+export function isValidANSName(name: string): { domainName: string; subdomainName?: string } {
+  const [first, second, ...rest] = name.replace(/\.apt$/, "").split(".");
+
+  if (rest.length > 0) {
+    throw new Error(`${name} is invalid. A name can only have two parts, a domain and a subdomain separated by a "."`);
+  }
+
+  if (!isValidANSSegment(first)) {
+    throw new Error(`${first} is not valid. ${VALIDATION_RULES_DESCRIPTION}`);
+  }
+
+  if (second && !isValidANSSegment(second)) {
+    throw new Error(`${second} is not valid. ${VALIDATION_RULES_DESCRIPTION}`);
+  }
+
+  return {
+    domainName: second || first,
+    subdomainName: second ? first : undefined,
+  };
+}
+
+export const LOCAL_ANS_ACCOUNT_PK =
+  (process.env.ANS_TEST_ACCOUNT_PRIVATE_KEY as string) ||
+  "0x37368b46ce665362562c6d1d4ec01a08c8644c488690df5a17e13ba163e20221";
+export const LOCAL_ANS_ACCOUNT_ADDRESS =
+  (process.env.ANS_TEST_ACCOUNT_ADDRESS as string) ||
+  "0x585fc9f0f0c54183b039ffc770ca282ebd87307916c215a3e692f2f8e4305e82";
+
+const NetworkToAnsContract: Record<Network, string | null> = {
+  [Network.TESTNET]: "0x5f8fd2347449685cf41d4db97926ec3a096eaf381332be4f1318ad4d16a8497c",
+  [Network.MAINNET]: "0x867ed1f6bf916171b1de3ee92849b8978b7d1b9e0a8cc982a3d19d535dfd9c0c",
+  [Network.LOCAL]: LOCAL_ANS_ACCOUNT_ADDRESS,
+  [Network.CUSTOM]: null,
+  [Network.DEVNET]: null,
+};
+
+function getRouterAddress(aptosConfig: AptosConfig): string {
+  const address = NetworkToAnsContract[aptosConfig.network];
+  if (!address) throw new Error(`The ANS contract is not deployed to ${aptosConfig.network}`);
+  return address;
+}
+
+const Some = <T>(value: T): MoveValue => ({ vec: [value] } as any);
+const None = (): MoveValue => ({ vec: [] } as any);
+// != here is intentional, we want to check for null and undefined
+// eslint-disable-next-line eqeqeq
+const Option = <T>(value: T | undefined | null): MoveValue => (value != undefined ? Some(value) : None());
+
+const unwrapOption = <T>(option: any): T | undefined => {
+  if (!!option && typeof option === "object" && "vec" in option && Array.isArray(option.vec)) {
+    return option.vec[0];
+  }
+
+  return undefined;
+};
+
+export async function getOwnerAddress(args: { aptosConfig: AptosConfig; name: string }): Promise<string | undefined> {
+  const { aptosConfig, name } = args;
+  const routerAddress = getRouterAddress(aptosConfig);
+  const { domainName, subdomainName } = isValidANSName(name);
+
+  const res = await view({
+    aptosConfig,
+    payload: {
+      function: `${routerAddress}::router::get_owner_addr`,
+      functionArguments: [domainName, Option(subdomainName)],
+    },
+  });
+
+  const owner = unwrapOption<MoveAddressType>(res[0]);
+
+  return owner ? AccountAddress.fromRelaxed(owner).toString() : undefined;
+}
+
+export interface RegisterNameParameters {
+  aptosConfig: AptosConfig;
+  sender: Account;
+  name: string;
+  expiration:
+    | { policy: "domain"; years: 1 }
+    | { policy: "subdomain:follow-domain" }
+    | { policy: "subdomain:independent"; expirationDate: Date };
+  transferable?: boolean;
+  toAddress?: HexInput;
+  targetAddress?: HexInput;
+  options?: InputGenerateTransactionOptions;
+}
+
+export async function registerName(args: RegisterNameParameters): Promise<InputSingleSignerTransaction> {
+  const { aptosConfig, expiration, name, sender, targetAddress, toAddress, options } = args;
+  const routerAddress = getRouterAddress(aptosConfig);
+  const { domainName, subdomainName } = isValidANSName(name);
+
+  const hasSubdomainPolicy =
+    expiration.policy === "subdomain:independent" || expiration.policy === "subdomain:follow-domain";
+
+  if (subdomainName && !hasSubdomainPolicy) {
+    throw new Error(
+      "Subdomains must have an expiration policy of either 'subdomain:independent' or 'subdomain:follow-domain'",
+    );
+  }
+
+  if (hasSubdomainPolicy && !subdomainName) {
+    throw new Error(`Policy is set to ${expiration.policy} but no subdomain was provided`);
+  }
+
+  if (expiration.policy === "domain") {
+    if (expiration.years !== 1) {
+      throw new Error("For now, names can only be registered for 1 year at a time");
+    }
+
+    const registrationDuration = expiration.years * 31536000;
+
+    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),
+        ],
+      },
+      options,
+    });
+
+    return transaction as InputSingleSignerTransaction;
+  }
+
+  throw new Error(`Policy ${expiration.policy} is not supported yet`);
+}

package/src/internal/coin.ts

@@ -1,8 +1,8 @@
 import { AptosConfig } from "../api/aptosConfig";
 import { U64 } from "../bcs/serializable/movePrimitives";
-import { Account, AccountAddress } from "../core";
+import { Account, AccountAddress, AccountAddressInput } from "../core";
 import { InputGenerateTransactionOptions, InputSingleSignerTransaction } from "../transactions/types";
-import { HexInput, AnyNumber, MoveStructType } from "../types";
+import { AnyNumber, MoveStructType } from "../types";
 import { APTOS_COIN } from "../utils/const";
 import { generateTransaction } from "./transactionSubmission";
 import { parseTypeTag } from "../transactions/typeTag/parser";
@@ -10,7 +10,7 @@ import { parseTypeTag } from "../transactions/typeTag/parser";
 export async function transferCoinTransaction(args: {
   aptosConfig: AptosConfig;
   sender: Account;
-  recipient: HexInput;
+  recipient: AccountAddressInput;
   amount: AnyNumber;
   coinType?: MoveStructType;
   options?: InputGenerateTransactionOptions;
@@ -19,11 +19,11 @@ export async function transferCoinTransaction(args: {
   const coinStructType = coinType ?? APTOS_COIN;
   const transaction = await generateTransaction({
     aptosConfig,
-    sender: sender.accountAddress.toString(),
+    sender: sender.accountAddress,
     data: {
       function: "0x1::aptos_account::transfer_coins",
       typeArguments: [parseTypeTag(coinStructType)],
-      functionArguments: [AccountAddress.fromHexInput(recipient), new U64(amount)],
+      functionArguments: [AccountAddress.from(recipient), new U64(amount)],
     },
     options,
   });

package/src/internal/digitalAsset.ts

@@ -10,7 +10,7 @@
 
 import { AptosConfig } from "../api/aptosConfig";
 import { MoveString, MoveVector, Bool, U64, U8 } from "../bcs";
-import { Account, Hex } from "../core";
+import { Account, AccountAddress, AccountAddressInput } from "../core";
 import { InputGenerateTransactionOptions, InputSingleSignerTransaction } from "../transactions/types";
 import {
   AnyNumber,
@@ -19,7 +19,6 @@ import {
   GetOwnedTokensResponse,
   GetTokenActivityResponse,
   GetTokenDataResponse,
-  HexInput,
   OrderBy,
   PaginationArgs,
   TokenStandard,
@@ -60,7 +59,7 @@ export async function mintTokenTransaction(args: {
   const { aptosConfig, options, creator } = args;
   const transaction = await generateTransaction({
     aptosConfig,
-    sender: creator.accountAddress.toString(),
+    sender: creator.accountAddress,
     data: {
       function: "0x4::aptos_token::mint",
       functionArguments: [
@@ -80,12 +79,12 @@ export async function mintTokenTransaction(args: {
 
 export async function getTokenData(args: {
   aptosConfig: AptosConfig;
-  tokenAddress: HexInput;
+  tokenAddress: AccountAddressInput;
 }): Promise<GetTokenDataResponse> {
   const { aptosConfig, tokenAddress } = args;
 
-  const whereCondition: any = {
-    token_data_id: { _eq: Hex.fromHexInput(tokenAddress).toString() },
+  const whereCondition: { token_data_id: { _eq: string } } = {
+    token_data_id: { _eq: AccountAddress.from(tokenAddress).toStringLong() },
   };
 
   const graphqlQuery = {
@@ -106,12 +105,12 @@ export async function getTokenData(args: {
 
 export async function getCurrentTokenOwnership(args: {
   aptosConfig: AptosConfig;
-  tokenAddress: HexInput;
+  tokenAddress: AccountAddressInput;
 }): Promise<GetCurrentTokenOwnershipResponse> {
   const { aptosConfig, tokenAddress } = args;
 
   const whereCondition: CurrentTokenOwnershipsV2BoolExp = {
-    token_data_id: { _eq: Hex.fromHexInput(tokenAddress).toString() },
+    token_data_id: { _eq: AccountAddress.from(tokenAddress).toStringLong() },
   };
 
   const graphqlQuery = {
@@ -132,7 +131,7 @@ export async function getCurrentTokenOwnership(args: {
 
 export async function getOwnedTokens(args: {
   aptosConfig: AptosConfig;
-  ownerAddress: HexInput;
+  ownerAddress: AccountAddressInput;
   options?: {
     pagination?: PaginationArgs;
     orderBy?: OrderBy<GetTokenActivityResponse[0]>;
@@ -141,7 +140,7 @@ export async function getOwnedTokens(args: {
   const { aptosConfig, ownerAddress, options } = args;
 
   const whereCondition: CurrentTokenOwnershipsV2BoolExp = {
-    owner_address: { _eq: Hex.fromHexInput(ownerAddress).toString() },
+    owner_address: { _eq: AccountAddress.from(ownerAddress).toStringLong() },
   };
 
   const graphqlQuery = {
@@ -165,7 +164,7 @@ export async function getOwnedTokens(args: {
 
 export async function getTokenActivity(args: {
   aptosConfig: AptosConfig;
-  tokenAddress: HexInput;
+  tokenAddress: AccountAddressInput;
   options?: {
     pagination?: PaginationArgs;
     orderBy?: OrderBy<GetTokenActivityResponse[0]>;
@@ -174,7 +173,7 @@ export async function getTokenActivity(args: {
   const { aptosConfig, tokenAddress, options } = args;
 
   const whereCondition: TokenActivitiesV2BoolExp = {
-    token_data_id: { _eq: Hex.fromHexInput(tokenAddress).toString() },
+    token_data_id: { _eq: AccountAddress.from(tokenAddress).toStringLong() },
   };
 
   const graphqlQuery = {
@@ -224,7 +223,7 @@ export async function createCollectionTransaction(
   const { aptosConfig, options, creator } = args;
   const transaction = await generateTransaction({
     aptosConfig,
-    sender: creator.accountAddress.toString(),
+    sender: creator.accountAddress,
     data: {
       function: "0x4::aptos_token::create_collection",
       functionArguments: [
@@ -253,18 +252,18 @@ export async function createCollectionTransaction(
 
 export async function getCollectionData(args: {
   aptosConfig: AptosConfig;
-  creatorAddress: HexInput;
+  creatorAddress: AccountAddressInput;
   collectionName: string;
   options?: {
     tokenStandard?: TokenStandard;
   };
 }): Promise<GetCollectionDataResponse> {
   const { aptosConfig, creatorAddress, collectionName, options } = args;
-  const address = Hex.fromHexInput(creatorAddress).toString();
+  const address = AccountAddress.from(creatorAddress);
 
   const whereCondition: any = {
     collection_name: { _eq: collectionName },
-    creator_address: { _eq: address },
+    creator_address: { _eq: address.toStringLong() },
   };
 
   if (options?.tokenStandard) {
@@ -288,7 +287,7 @@ export async function getCollectionData(args: {
 
 export async function getCollectionId(args: {
   aptosConfig: AptosConfig;
-  creatorAddress: HexInput;
+  creatorAddress: AccountAddressInput;
   collectionName: string;
   options?: {
     tokenStandard?: TokenStandard;

package/src/internal/event.ts

@@ -9,8 +9,8 @@
  */
 
 import { AptosConfig } from "../api/aptosConfig";
-import { AccountAddress } from "../core";
-import { AnyNumber, GetEventsResponse, HexInput, PaginationArgs, MoveStructType, OrderBy } from "../types";
+import { AccountAddress, AccountAddressInput } from "../core";
+import { AnyNumber, GetEventsResponse, PaginationArgs, MoveStructType, OrderBy } from "../types";
 import { GetEventsQuery } from "../types/generated/operations";
 import { GetEvents } from "../types/generated/queries";
 import { EventsBoolExp } from "../types/generated/types";
@@ -18,14 +18,14 @@ import { queryIndexer } from "./general";
 
 export async function getAccountEventsByCreationNumber(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
+  accountAddress: AccountAddressInput;
   creationNumber: AnyNumber;
 }): Promise<GetEventsResponse> {
   const { accountAddress, aptosConfig, creationNumber } = args;
-  const address = AccountAddress.fromHexInput(accountAddress).toString();
+  const address = AccountAddress.from(accountAddress);
 
   const whereCondition: EventsBoolExp = {
-    account_address: { _eq: address },
+    account_address: { _eq: address.toStringLong() },
     creation_number: { _eq: creationNumber },
   };
 
@@ -34,7 +34,7 @@ export async function getAccountEventsByCreationNumber(args: {
 
 export async function getAccountEventsByEventType(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
+  accountAddress: AccountAddressInput;
   eventType: MoveStructType;
   options?: {
     pagination?: PaginationArgs;
@@ -42,7 +42,7 @@ export async function getAccountEventsByEventType(args: {
   };
 }): Promise<GetEventsResponse> {
   const { accountAddress, aptosConfig, eventType, options } = args;
-  const address = AccountAddress.fromHexInput(accountAddress).toString();
+  const address = AccountAddress.fromRelaxed(accountAddress).toStringLong();
 
   const whereCondition: EventsBoolExp = {
     account_address: { _eq: address },

package/src/internal/faucet.ts

@@ -10,14 +10,14 @@
 
 import { AptosConfig } from "../api/aptosConfig";
 import { postAptosFaucet } from "../client";
-import { AccountAddress } from "../core";
-import { HexInput, WaitForTransactionOptions } from "../types";
+import { AccountAddress, AccountAddressInput } from "../core";
+import { WaitForTransactionOptions } from "../types";
 import { DEFAULT_TXN_TIMEOUT_SEC } from "../utils/const";
 import { waitForTransaction } from "./transaction";
 
 export async function fundAccount(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
+  accountAddress: AccountAddressInput;
   amount: number;
   options?: WaitForTransactionOptions;
 }): Promise<string> {
@@ -27,7 +27,7 @@ export async function fundAccount(args: {
     aptosConfig,
     path: "fund",
     body: {
-      address: AccountAddress.fromHexInput(accountAddress).toString(),
+      address: AccountAddress.fromRelaxed(accountAddress).toString(),
       amount,
     },
     originMethod: "fundAccount",

package/src/internal/general.ts

@@ -66,12 +66,12 @@ export async function getBlockByHeight(args: {
   return data;
 }
 
-export async function getTableItem(args: {
+export async function getTableItem<T>(args: {
   aptosConfig: AptosConfig;
   handle: string;
   data: TableItemRequest;
   options?: LedgerVersion;
-}): Promise<any> {
+}): Promise<T> {
   const { aptosConfig, handle, data, options } = args;
   const response = await postAptosFullNode<TableItemRequest, any>({
     aptosConfig,
@@ -80,7 +80,7 @@ export async function getTableItem(args: {
     params: { ledger_version: options?.ledgerVersion },
     body: data,
   });
-  return response.data;
+  return response.data as T;
 }
 
 export async function view(args: {

package/src/internal/staking.ts

@@ -9,18 +9,18 @@
  */
 
 import { AptosConfig } from "../api/aptosConfig";
-import { Hex } from "../core";
-import { GetDelegatedStakingActivitiesResponse, GetNumberOfDelegatorsResponse, HexInput, OrderBy } from "../types";
+import { AccountAddress, AccountAddressInput } from "../core";
+import { GetDelegatedStakingActivitiesResponse, GetNumberOfDelegatorsResponse, OrderBy } from "../types";
 import { GetDelegatedStakingActivitiesQuery, GetNumberOfDelegatorsQuery } from "../types/generated/operations";
 import { GetDelegatedStakingActivities, GetNumberOfDelegators } from "../types/generated/queries";
 import { queryIndexer } from "./general";
 
 export async function getNumberOfDelegators(args: {
   aptosConfig: AptosConfig;
-  poolAddress: HexInput;
+  poolAddress: AccountAddressInput;
 }): Promise<number> {
   const { aptosConfig, poolAddress } = args;
-  const address = Hex.fromHexInput(poolAddress).toString();
+  const address = AccountAddress.fromRelaxed(poolAddress).toStringLong();
   const query = {
     query: GetNumberOfDelegators,
     variables: { where_condition: { pool_address: { _eq: address } } },
@@ -52,15 +52,15 @@ export async function getNumberOfDelegatorsForAllPools(args: {
 
 export async function getDelegatedStakingActivities(args: {
   aptosConfig: AptosConfig;
-  delegatorAddress: HexInput;
-  poolAddress: HexInput;
+  delegatorAddress: AccountAddressInput;
+  poolAddress: AccountAddressInput;
 }): Promise<GetDelegatedStakingActivitiesResponse> {
   const { aptosConfig, delegatorAddress, poolAddress } = args;
   const query = {
     query: GetDelegatedStakingActivities,
     variables: {
-      delegatorAddress: Hex.fromHexInput(delegatorAddress).toString(),
-      poolAddress: Hex.fromHexInput(poolAddress).toString(),
+      delegatorAddress: AccountAddress.fromRelaxed(delegatorAddress).toStringLong(),
+      poolAddress: AccountAddress.fromRelaxed(poolAddress).toStringLong(),
     },
   };
   const data = await queryIndexer<GetDelegatedStakingActivitiesQuery>({ aptosConfig, query });

package/src/internal/transactionSubmission.ts

@@ -6,10 +6,13 @@
  */
 
 import { AptosConfig } from "../api/aptosConfig";
-import { MoveVector } from "../bcs";
+import { MoveVector, U8 } from "../bcs";
 import { postAptosFullNode } from "../client";
 import { Account } from "../core/account";
+import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
+import { PrivateKey } from "../core/crypto";
 import { AccountAuthenticator } from "../transactions/authenticator/account";
+import { RotationProofChallenge } from "../transactions/instances/rotationProofChallenge";
 import {
   buildTransaction,
   generateTransactionPayload,
@@ -24,13 +27,15 @@ import {
   InputGenerateTransactionOptions,
   InputSingleSignerTransaction,
   InputGenerateTransactionPayloadDataWithRemoteABI,
+  InputSubmitTransactionData,
 } from "../transactions/types";
-import { UserTransactionResponse, PendingTransactionResponse, MimeType, HexInput } from "../types";
+import { getInfo } from "./account";
+import { UserTransactionResponse, PendingTransactionResponse, MimeType, HexInput, TransactionResponse } from "../types";
 
 /**
  * Generates any transaction by passing in the required arguments
  *
- * @param args.sender The transaction sender's account address as a HexInput
+ * @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
@@ -58,10 +63,10 @@ import { UserTransactionResponse, PendingTransactionResponse, MimeType, HexInput
  * }
  * ```
  *
- * @return A raw transaction type (note that it holds the raw transaction as a bcs serialized data)
+ * @return An instance of a RawTransaction, plus optional secondary/fee payer addresses
  * ```
  * {
- *  rawTransaction: Uint8Array,
+ *  rawTransaction: RawTransaction,
  *  secondarySignerAddresses? : Array<AccountAddress>,
  *  feePayerAddress?: AccountAddress
  * }
@@ -107,10 +112,10 @@ export async function generateTransaction(
  * Sign a transaction that can later be submitted to chain
  *
  * @param args.signer The signer account to sign the transaction
- * @param args.transaction A raw transaction type (note that it holds the raw transaction as a bcs serialized data)
+ * @param args.transaction An instance of a RawTransaction, plus optional secondary/fee payer addresses
  * ```
  * {
- *  rawTransaction: Uint8Array,
+ *  rawTransaction: RawTransaction,
  *  secondarySignerAddresses? : Array<AccountAddress>,
  *  feePayerAddress?: AccountAddress
  * }
@@ -169,15 +174,11 @@ export async function simulateTransaction(
  *
  * @return PendingTransactionResponse
  */
-export async function submitTransaction(args: {
-  aptosConfig: AptosConfig;
-  transaction: AnyRawTransaction;
-  senderAuthenticator: AccountAuthenticator;
-  secondarySignerAuthenticators?: {
-    feePayerAuthenticator?: AccountAuthenticator;
-    additionalSignersAuthenticators?: Array<AccountAuthenticator>;
-  };
-}): Promise<PendingTransactionResponse> {
+export async function submitTransaction(
+  args: {
+    aptosConfig: AptosConfig;
+  } & InputSubmitTransactionData,
+): Promise<PendingTransactionResponse> {
   const { aptosConfig } = args;
   const signedTransaction = generateSignedTransaction({ ...args });
   const { data } = await postAptosFullNode<Uint8Array, PendingTransactionResponse>({
@@ -206,7 +207,7 @@ export async function signAndSubmitTransaction(args: {
 
 export async function publicPackageTransaction(args: {
   aptosConfig: AptosConfig;
-  account: HexInput;
+  account: AccountAddressInput;
   metadataBytes: HexInput;
   moduleBytecode: Array<HexInput>;
   options?: InputGenerateTransactionOptions;
@@ -217,7 +218,7 @@ export async function publicPackageTransaction(args: {
 
   const transaction = await generateTransaction({
     aptosConfig,
-    sender: account,
+    sender: AccountAddress.fromRelaxed(account),
     data: {
       function: "0x1::code::publish_package_txn",
       functionArguments: [MoveVector.U8(metadataBytes), new MoveVector(totalByteCode)],
@@ -226,3 +227,55 @@ export async function publicPackageTransaction(args: {
   });
   return transaction as InputSingleSignerTransaction;
 }
+
+/**
+ * TODO: Need to refactor and move this function out of transactionSubmission
+ */
+export async function rotateAuthKey(args: {
+  aptosConfig: AptosConfig;
+  fromAccount: Account;
+  toNewPrivateKey: PrivateKey;
+}): Promise<TransactionResponse> {
+  const { aptosConfig, fromAccount, toNewPrivateKey } = args;
+  const accountInfo = await getInfo({
+    aptosConfig,
+    accountAddress: fromAccount.accountAddress.toString(),
+  });
+
+  const newAccount = Account.fromPrivateKey({ privateKey: toNewPrivateKey, legacy: true });
+
+  const challenge = new RotationProofChallenge({
+    sequenceNumber: BigInt(accountInfo.sequence_number),
+    originator: fromAccount.accountAddress,
+    currentAuthKey: AccountAddress.from(accountInfo.authentication_key),
+    newPublicKey: newAccount.publicKey,
+  });
+
+  // Sign the challenge
+  const challengeHex = challenge.bcsToBytes();
+  const proofSignedByCurrentPrivateKey = fromAccount.sign(challengeHex);
+  const proofSignedByNewPrivateKey = newAccount.sign(challengeHex);
+
+  // Generate transaction
+  const rawTxn = await generateTransaction({
+    aptosConfig,
+    sender: fromAccount.accountAddress.toString(),
+    data: {
+      function: "0x1::account::rotate_authentication_key",
+      functionArguments: [
+        new U8(fromAccount.signingScheme.valueOf()), // from scheme
+        MoveVector.U8(fromAccount.publicKey.toUint8Array()),
+        new U8(newAccount.signingScheme.valueOf()), // to scheme
+        MoveVector.U8(newAccount.publicKey.toUint8Array()),
+        MoveVector.U8(proofSignedByCurrentPrivateKey.toUint8Array()),
+        MoveVector.U8(proofSignedByNewPrivateKey.toUint8Array()),
+      ],
+    },
+  });
+  const pendingTxn = await signAndSubmitTransaction({
+    aptosConfig,
+    signer: fromAccount,
+    transaction: rawTxn,
+  });
+  return pendingTxn;
+}

package/src/transactions/instances/index.ts

@@ -5,6 +5,7 @@ export * from "./chainId";
 export * from "./identifier";
 export * from "./moduleId";
 export * from "./rawTransaction";
+export * from "./rotationProofChallenge";
 export * from "./signedTransaction";
 export * from "./transactionArgument";
 export * from "./transactionPayload";

package/src/transactions/instances/moduleId.ts

@@ -37,7 +37,7 @@ export class ModuleId extends Serializable {
     if (parts.length !== 2) {
       throw new Error("Invalid module id.");
     }
-    return new ModuleId(AccountAddress.fromString(parts[0]), new Identifier(parts[1]));
+    return new ModuleId(AccountAddress.fromStringRelaxed(parts[0]), new Identifier(parts[1]));
   }
 
   serialize(serializer: Serializer): void {