@aptos-labs/ts-sdk 1.33.2-sc.0 → 1.34.0

package/src/api/account/abstraction.ts

@@ -0,0 +1,239 @@
+import { AccountAddress, AccountAddressInput } from "../../core";
+import {
+  addAuthenticationFunctionTransaction,
+  removeAuthenticationFunctionTransaction,
+  removeDispatchableAuthenticatorTransaction,
+} from "../../internal/abstraction";
+import { view } from "../../internal/view";
+import { InputGenerateTransactionOptions, TypeTagAddress } from "../../transactions";
+import { MoveFunctionId } from "../../types";
+import { getFunctionParts } from "../../utils/helpers";
+import { AptosConfig } from "../aptosConfig";
+
+export class AccountAbstraction {
+  constructor(readonly config: AptosConfig) {}
+
+  /**
+   * Adds a dispatchable authentication function to the account.
+   *
+   * @example
+   * ```ts
+   * const txn = await aptos.abstraction.addAuthenticationFunctionTransaction({
+   *   accountAddress: alice.accountAddress,
+   *   authenticationFunction: `${alice.accountAddress}::any_authenticator::authenticate`,
+   * });
+   *
+   * const txn =  await aptos.signAndSubmitTransaction({ signer: alice, transaction});
+   * await aptos.waitForTransaction({ transactionHash: txn.hash });
+   * ```
+   *
+   * @param args.accountAddress - The account to add the authentication function to.
+   * @param args.authenticationFunction - The authentication function info to add.
+   * @param args.options - The options for the transaction.
+   * @returns A transaction to add the authentication function to the account.
+   */
+  public async addAuthenticationFunctionTransaction(args: {
+    accountAddress: AccountAddressInput;
+    authenticationFunction: string;
+    options?: InputGenerateTransactionOptions;
+  }) {
+    const { accountAddress, authenticationFunction, options } = args;
+    return addAuthenticationFunctionTransaction({
+      aptosConfig: this.config,
+      authenticationFunction,
+      sender: accountAddress,
+      options,
+    });
+  }
+
+  /**
+   * Removes a dispatchable authentication function from the account.
+   *
+   * @example
+   * ```ts
+   * const txn = await aptos.abstraction.removeAuthenticationFunctionTransaction({
+   *   accountAddress: alice.accountAddress,
+   *   authenticationFunction: `${alice.accountAddress}::any_authenticator::authenticate`,
+   * });
+   *
+   * const txn = await aptos.signAndSubmitTransaction({ signer: alice, transaction: txn });
+   * await aptos.waitForTransaction({ transactionHash: txn.hash });
+   * ```
+   *
+   * @param args.accountAddress - The account to remove the authentication function from.
+   * @param args.authenticationFunction - The authentication function info to remove.
+   * @param args.options - The options for the transaction.
+   * @returns A transaction to remove the authentication function from the account.
+   */
+  public async removeAuthenticationFunctionTransaction(args: {
+    accountAddress: AccountAddressInput;
+    authenticationFunction: string;
+    options?: InputGenerateTransactionOptions;
+  }) {
+    const { accountAddress, authenticationFunction, options } = args;
+    return removeAuthenticationFunctionTransaction({
+      aptosConfig: this.config,
+      sender: accountAddress,
+      authenticationFunction,
+      options,
+    });
+  }
+
+  /**
+   * Removes a dispatchable authenticator from the account.
+   *
+   * @example
+   * ```ts
+   * const txn = await aptos.abstraction.removeDispatchableAuthenticatorTransaction({
+   *   accountAddress: alice.accountAddress,
+   * });
+   *
+   * const txn = await aptos.signAndSubmitTransaction({ signer: alice, transaction: txn });
+   * await aptos.waitForTransaction({ transactionHash: txn.hash });
+   * ```
+   *
+   * @param args.accountAddress - The account to remove the authenticator from.
+   * @param args.options - The options for the transaction.
+   * @returns A transaction to remove the authenticator from the account.
+   */
+  public async removeDispatchableAuthenticatorTransaction(args: {
+    accountAddress: AccountAddressInput;
+    options?: InputGenerateTransactionOptions;
+  }) {
+    const { accountAddress, options } = args;
+    return removeDispatchableAuthenticatorTransaction({ aptosConfig: this.config, sender: accountAddress, options });
+  }
+
+  /**
+   * Gets the dispatchable authentication function for the account.
+   *
+   * @example
+   * ```ts
+   * const functionInfos = await aptos.abstraction.getAuthenticationFunction({
+   *   accountAddress: alice.accountAddress,
+   * });
+   *
+   * if (functionInfos) {
+   *   console.log(`Account ${alice.accountAddress.toString()} is using account abstraction!`);
+   * } else {
+   *   console.log(`Account ${alice.accountAddress.toString()} is not using account abstraction.`);
+   * }
+   * ```
+   *
+   * @param args.accountAddress - The account to get the dispatchable authentication function for.
+   * @returns The dispatchable authentication function for the account.
+   */
+  public async getAuthenticationFunction(args: { accountAddress: AccountAddressInput }) {
+    const { accountAddress } = args;
+    const [{ vec: functionInfoOption }] = await view<
+      [{ vec: { function_name: string; module_name: string; module_address: string }[][] }]
+    >({
+      aptosConfig: this.config,
+      payload: {
+        function: "0x1::account_abstraction::dispatchable_authenticator",
+        functionArguments: [AccountAddress.from(accountAddress)],
+        abi: { typeParameters: [], parameters: [new TypeTagAddress()], returnTypes: [] },
+      },
+    });
+
+    if (functionInfoOption.length === 0) return undefined;
+
+    return functionInfoOption[0].map((functionInfo) => ({
+      moduleAddress: AccountAddress.fromString(functionInfo.module_address),
+      moduleName: functionInfo.module_name,
+      functionName: functionInfo.function_name,
+    }));
+  }
+
+  /**
+   * Will return true if the account is abstracted, otherwise false.
+   *
+   * @example
+   * ```ts
+   * const isAccountAbstractionEnabled = await aptos.abstraction.isAccountAbstractionEnabled({
+   *   accountAddress: alice.accountAddress,
+   *   authenticationFunction: `${alice.accountAddress}::any_authenticator::authenticate`,
+   * });
+   * if (isAccountAbstractionEnabled) {
+   *   console.log(`Account ${alice.accountAddress.toString()} is using account abstraction!`);
+   * } else {
+   *   console.log(`Account ${alice.accountAddress.toString()} is not using account abstraction.`);
+   * }
+   * ```
+   *
+   * @param args.accountAddress - The account to check.
+   * @returns Whether the account is abstracted.
+   */
+  public isAccountAbstractionEnabled = async (args: {
+    accountAddress: AccountAddressInput;
+    authenticationFunction: string;
+  }) => {
+    const functionInfos = await this.getAuthenticationFunction(args);
+    const { moduleAddress, moduleName, functionName } = getFunctionParts(args.authenticationFunction as MoveFunctionId);
+    return (
+      functionInfos?.some(
+        (functionInfo) =>
+          AccountAddress.fromString(moduleAddress).equals(functionInfo.moduleAddress) &&
+          moduleName === functionInfo.moduleName &&
+          functionName === functionInfo.functionName,
+      ) ?? false
+    );
+  };
+
+  /**
+   * Creates a transaction to enable account abstraction with the given authentication function.
+   *
+   * @example
+   * ```ts
+   * const txn = await aptos.abstraction.enableAccountAbstractionTransaction({
+   *   accountAddress: alice.accountAddress,
+   *   authenticationFunction: `{alice.accountAddress}::any_authenticator::authenticate`,
+   * });
+   *
+   * const txn = await aptos.signAndSubmitTransaction({ signer: alice, transaction: txn });
+   * await aptos.waitForTransaction({ transactionHash: txn.hash });
+   * ```
+   *
+   * @param args.accountAddress - The account to enable account abstraction for.
+   * @param args.authenticationFunction - The authentication function info to use.
+   * @param args.options - The options for the transaction.
+   * @returns A transaction to enable account abstraction for the account.
+   */
+  public enableAccountAbstractionTransaction = this.addAuthenticationFunctionTransaction;
+
+  /**
+   * Creates a transaction to disable account abstraction. If an authentication function is provided, it will specify to
+   * remove the authentication function.
+   *
+   * @example
+   * ```ts
+   * const txn = await aptos.abstraction.disableAccountAbstractionTransaction({
+   *   accountAddress: alice.accountAddress,
+   *   authenticationFunction: `${alice.accountAddress}::any_authenticator::authenticate`,
+   * });
+   *
+   * const txn = await aptos.signAndSubmitTransaction({ signer: alice, transaction: txn });
+   * await aptos.waitForTransaction({ transactionHash: txn.hash });
+   * ```
+   *
+   * @param args.accountAddress - The account to disable account abstraction for.
+   * @param args.authenticationFunction - The authentication function info to remove.
+   * @param args.options - The options for the transaction.
+   * @returns A transaction to disable account abstraction for the account.
+   */
+  public disableAccountAbstractionTransaction = async (args: {
+    accountAddress: AccountAddressInput;
+    authenticationFunction?: string;
+    options?: InputGenerateTransactionOptions;
+  }) => {
+    const { accountAddress, authenticationFunction, options } = args;
+    if (authenticationFunction) {
+      return this.removeAuthenticationFunctionTransaction({
+        accountAddress,
+        authenticationFunction,
+        options,
+      });
+    }
+    return this.removeDispatchableAuthenticatorTransaction({ accountAddress, options });
+  };
+}

package/src/api/account.ts

@@ -47,12 +47,15 @@ import { CurrentFungibleAssetBalancesBoolExp } from "../types/generated/types";
 import { view } from "../internal/view";
 import { isEncodedStruct, parseEncodedStruct } from "../utils";
 import { memoizeAsync } from "../utils/memoize";
+import { AccountAbstraction } from "./account/abstraction";
 
 /**
  * A class to query all `Account` related queries on Aptos.
  * @group Account
  */
 export class Account {
+  abstraction: AccountAbstraction;
+
   /**
    * Creates an instance of the Aptos client with the provided configuration.
    *
@@ -73,7 +76,9 @@ export class Account {
    * ```
    * @group Account
    */
-  constructor(readonly config: AptosConfig) {}
+  constructor(readonly config: AptosConfig) {
+    this.abstraction = new AccountAbstraction(config);
+  }
 
   /**
    * Queries the current state for an Aptos account given its account address.

package/src/api/aptos.ts

@@ -15,6 +15,7 @@ import { Transaction } from "./transaction";
 import { Table } from "./table";
 import { Keyless } from "./keyless";
 import { AptosObject } from "./object";
+import { AccountAbstraction } from "./account/abstraction";
 
 /**
  * The main entry point for interacting with the Aptos APIs,
@@ -94,6 +95,7 @@ export class Aptos {
   constructor(settings?: AptosConfig) {
     this.config = new AptosConfig(settings);
     this.account = new Account(this.config);
+    this.abstraction = new AccountAbstraction(this.config);
     this.ans = new ANS(this.config);
     this.coin = new Coin(this.config);
     this.digitalAsset = new DigitalAsset(this.config);
@@ -149,6 +151,7 @@ function applyMixin(targetClass: any, baseClass: any, baseClassProp: string) {
 }
 
 applyMixin(Aptos, Account, "account");
+applyMixin(Aptos, AccountAbstraction, "abstraction");
 applyMixin(Aptos, ANS, "ans");
 applyMixin(Aptos, Coin, "coin");
 applyMixin(Aptos, DigitalAsset, "digitalAsset");

package/src/core/crypto/abstraction.ts

@@ -0,0 +1,47 @@
+import { Deserializer, Serializer } from "../../bcs";
+import { HexInput } from "../../types";
+import { AccountAddress } from "../accountAddress";
+import { AuthenticationKey } from "../authenticationKey";
+import { Hex } from "../hex";
+import { AccountPublicKey, VerifySignatureArgs } from "./publicKey";
+import { Signature } from "./signature";
+
+export class AbstractSignature extends Signature {
+  readonly value: Hex;
+
+  constructor(value: HexInput) {
+    super();
+    this.value = Hex.fromHexInput(value);
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeBytes(this.value.toUint8Array());
+  }
+
+  static deserialize(deserializer: Deserializer): AbstractSignature {
+    return new AbstractSignature(deserializer.deserializeBytes());
+  }
+}
+
+export class AbstractPublicKey extends AccountPublicKey {
+  readonly accountAddress: AccountAddress;
+
+  constructor(accountAddress: AccountAddress) {
+    super();
+    this.accountAddress = accountAddress;
+  }
+
+  authKey(): AuthenticationKey {
+    return new AuthenticationKey({ data: this.accountAddress.toUint8Array() });
+  }
+
+  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
+  verifySignature(args: VerifySignatureArgs): boolean {
+    throw new Error("This function is not implemented for AbstractPublicKey.");
+  }
+
+  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
+  serialize(serializer: Serializer): void {
+    throw new Error("This function is not implemented for AbstractPublicKey.");
+  }
+}

package/src/internal/abstraction.ts

@@ -0,0 +1,79 @@
+import {
+  SimpleTransaction,
+  InputGenerateTransactionOptions,
+  TypeTagAddress,
+  TypeTagStruct,
+  stringStructTag,
+} from "../transactions";
+import { AccountAddressInput } from "../core";
+import { generateTransaction } from "./transactionSubmission";
+import { MoveFunctionId } from "../types";
+import { AptosConfig } from "../api/aptosConfig";
+import { getFunctionParts } from "../utils/helpers";
+
+export async function addAuthenticationFunctionTransaction(args: {
+  aptosConfig: AptosConfig;
+  sender: AccountAddressInput;
+  authenticationFunction: string;
+  options?: InputGenerateTransactionOptions;
+}): Promise<SimpleTransaction> {
+  const { aptosConfig, sender, authenticationFunction, options } = args;
+  const { moduleAddress, moduleName, functionName } = getFunctionParts(authenticationFunction as MoveFunctionId);
+  return generateTransaction({
+    aptosConfig,
+    sender,
+    data: {
+      function: "0x1::account_abstraction::add_authentication_function",
+      typeArguments: [],
+      functionArguments: [moduleAddress, moduleName, functionName],
+      abi: {
+        typeParameters: [],
+        parameters: [new TypeTagAddress(), new TypeTagStruct(stringStructTag()), new TypeTagStruct(stringStructTag())],
+      },
+    },
+    options,
+  });
+}
+
+export async function removeAuthenticationFunctionTransaction(args: {
+  aptosConfig: AptosConfig;
+  sender: AccountAddressInput;
+  authenticationFunction: string;
+  options?: InputGenerateTransactionOptions;
+}) {
+  const { aptosConfig, sender, authenticationFunction, options } = args;
+  const { moduleAddress, moduleName, functionName } = getFunctionParts(authenticationFunction as MoveFunctionId);
+  return generateTransaction({
+    aptosConfig,
+    sender,
+    data: {
+      function: "0x1::account_abstraction::remove_authentication_function",
+      typeArguments: [],
+      functionArguments: [moduleAddress, moduleName, functionName],
+      abi: {
+        typeParameters: [],
+        parameters: [new TypeTagAddress(), new TypeTagStruct(stringStructTag()), new TypeTagStruct(stringStructTag())],
+      },
+    },
+    options,
+  });
+}
+
+export async function removeDispatchableAuthenticatorTransaction(args: {
+  aptosConfig: AptosConfig;
+  sender: AccountAddressInput;
+  options?: InputGenerateTransactionOptions;
+}) {
+  const { aptosConfig, sender, options } = args;
+  return generateTransaction({
+    aptosConfig,
+    sender,
+    data: {
+      function: "0x1::account_abstraction::remove_authenticator",
+      typeArguments: [],
+      functionArguments: [],
+      abi: { typeParameters: [], parameters: [] },
+    },
+    options,
+  });
+}

package/src/transactions/authenticator/account.ts

@@ -8,7 +8,10 @@ import { AnyPublicKey, AnySignature } from "../../core/crypto";
 import { Ed25519PublicKey, Ed25519Signature } from "../../core/crypto/ed25519";
 import { MultiEd25519PublicKey, MultiEd25519Signature } from "../../core/crypto/multiEd25519";
 import { MultiKey, MultiKeySignature } from "../../core/crypto/multiKey";
-import { AccountAuthenticatorVariant } from "../../types";
+import { AccountAuthenticatorVariant, HexInput, MoveFunctionId } from "../../types";
+import { AbstractionAuthDataVariant } from "../../types/abstraction";
+import { AccountAddress, Hex } from "../../core";
+import { getFunctionParts, isValidFunctionInfo } from "../../utils/helpers";
 
 /**
  * Represents an account authenticator that can handle multiple authentication variants.
@@ -43,6 +46,8 @@ export abstract class AccountAuthenticator extends Serializable {
         return AccountAuthenticatorMultiKey.load(deserializer);
       case AccountAuthenticatorVariant.NoAccountAuthenticator:
         return AccountAuthenticatorNoAccountAuthenticator.load(deserializer);
+      case AccountAuthenticatorVariant.Abstraction:
+        return AccountAuthenticatorAbstraction.load(deserializer);
       default:
         throw new Error(`Unknown variant index for AccountAuthenticator: ${index}`);
     }
@@ -263,3 +268,49 @@ export class AccountAuthenticatorNoAccountAuthenticator extends AccountAuthentic
     return new AccountAuthenticatorNoAccountAuthenticator();
   }
 }
+
+export class AccountAuthenticatorAbstraction extends AccountAuthenticator {
+  public readonly functionInfo: string;
+
+  public readonly signingMessageDigest: Hex;
+
+  public readonly authenticator: Hex;
+
+  constructor(functionInfo: string, signingMessageDigest: HexInput, authenticator: HexInput) {
+    super();
+    if (!isValidFunctionInfo(functionInfo)) {
+      throw new Error(`Invalid function info ${functionInfo} passed into AccountAuthenticatorAbstraction`);
+    }
+    this.functionInfo = functionInfo;
+    this.authenticator = Hex.fromHexInput(authenticator);
+    this.signingMessageDigest = Hex.fromHexInput(Hex.fromHexInput(signingMessageDigest).toUint8Array());
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(AccountAuthenticatorVariant.Abstraction);
+    const { moduleAddress, moduleName, functionName } = getFunctionParts(this.functionInfo as MoveFunctionId);
+    AccountAddress.fromString(moduleAddress).serialize(serializer);
+    serializer.serializeStr(moduleName);
+    serializer.serializeStr(functionName);
+    serializer.serializeU32AsUleb128(AbstractionAuthDataVariant.V1);
+    serializer.serializeBytes(this.signingMessageDigest.toUint8Array());
+    serializer.serializeFixedBytes(this.authenticator.toUint8Array());
+  }
+
+  static load(deserializer: Deserializer): AccountAuthenticatorAbstraction {
+    const moduleAddress = AccountAddress.deserialize(deserializer);
+    const moduleName = deserializer.deserializeStr();
+    const functionName = deserializer.deserializeStr();
+    const variant = deserializer.deserializeUleb128AsU32();
+    if (variant === AbstractionAuthDataVariant.V1) {
+      const signingMessageDigest = deserializer.deserializeBytes();
+      const authenticator = deserializer.deserializeFixedBytes(deserializer.remaining());
+      return new AccountAuthenticatorAbstraction(
+        `${moduleAddress}::${moduleName}::${functionName}`,
+        signingMessageDigest,
+        authenticator,
+      );
+    }
+    throw new Error(`Unknown variant index for AccountAuthenticatorAbstraction: ${variant}`);
+  }
+}

package/src/transactions/scriptComposer/index.ts

@@ -2,18 +2,19 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { ScriptComposerWasm } from "@aptos-labs/script-composer-pack";
-import { AptosApiType } from "../../utils";
+import { AptosApiType, getFunctionParts } from "../../utils";
 import { AptosConfig } from "../../api/aptosConfig";
 import { InputBatchedFunctionData } from "../types";
-import { fetchMoveFunctionAbi, getFunctionParts, standardizeTypeTags } from "../transactionBuilder";
+import { fetchMoveFunctionAbi, standardizeTypeTags } from "../transactionBuilder";
 import { CallArgument } from "../../types";
 import { convertCallArgument } from "../transactionBuilder/remoteAbi";
 
-// A wrapper class around TransactionComposer, which is a WASM library compiled
-// from aptos-core/aptos-move/script-composer.
-//
-// This class allows the SDK caller to build a transaction that invokes multiple Move functions
-// and allow for arguments to be passed around.
+/**
+ * A wrapper class around TransactionComposer, which is a WASM library compiled
+ * from aptos-core/aptos-move/script-composer.
+ * This class allows the SDK caller to build a transaction that invokes multiple Move functions
+ * and allow for arguments to be passed around.
+ * */
 export class AptosScriptComposer {
   private config: AptosConfig;
 

package/src/transactions/transactionBuilder/helpers.ts

@@ -10,7 +10,7 @@ import {
 } from "../types";
 import { Bool, FixedBytes, MoveOption, MoveString, MoveVector, U128, U16, U256, U32, U64, U8 } from "../../bcs";
 import { AccountAddress } from "../../core";
-import { MoveFunction, MoveFunctionId } from "../../types";
+import { MoveFunction } from "../../types";
 
 /**
  * Determines if the provided argument is of type boolean.
@@ -317,24 +317,3 @@ export function findFirstNonSignerArg(functionAbi: MoveFunction): number {
   }
   return index;
 }
-
-/**
- * Splits a function identifier into its constituent parts: module address, module name, and function name.
- * This function helps in validating and extracting details from a function identifier string.
- *
- * @param functionArg - The function identifier string in the format "moduleAddress::moduleName::functionName".
- * @returns An object containing the module address, module name, and function name.
- * @throws Error if the function identifier does not contain exactly three parts.
- * @group Implementation
- * @category Transactions
- */
-export function getFunctionParts(functionArg: MoveFunctionId) {
-  const funcNameParts = functionArg.split("::");
-  if (funcNameParts.length !== 3) {
-    throw new Error(`Invalid function ${functionArg}`);
-  }
-  const moduleAddress = funcNameParts[0];
-  const moduleName = funcNameParts[1];
-  const functionName = funcNameParts[2];
-  return { moduleAddress, moduleName, functionName };
-}

package/src/transactions/transactionBuilder/remoteAbi.ts

@@ -423,6 +423,13 @@ function parseArg(
       }
     }
 
+    if (isString(arg)) {
+      // In a web env, arguments are passing as strings
+      if (arg.startsWith("[")) {
+        return checkOrConvertArgument(JSON.parse(arg), param, position, genericTypeParams);
+      }
+    }
+
     // TODO: Support Uint16Array, Uint32Array, BigUint64Array?
 
     if (Array.isArray(arg)) {

package/src/transactions/transactionBuilder/transactionBuilder.ts

@@ -77,9 +77,10 @@ import {
 } from "../types";
 import { convertArgument, fetchEntryFunctionAbi, fetchViewFunctionAbi, standardizeTypeTags } from "./remoteAbi";
 import { memoizeAsync } from "../../utils/memoize";
-import { getFunctionParts, isScriptDataInput } from "./helpers";
+import { isScriptDataInput } from "./helpers";
 import { SimpleTransaction } from "../instances/simpleTransaction";
 import { MultiAgentTransaction } from "../instances/multiAgentTransaction";
+import { getFunctionParts } from "../../utils/helpers";
 
 /**
  * Builds a transaction payload based on the provided arguments and returns a transaction payload.

package/src/types/abstraction.ts

@@ -0,0 +1,6 @@
+/**
+ * The variant for the AbstractionAuthData enum.
+ */
+export enum AbstractionAuthDataVariant {
+  V1 = 0,
+}

package/src/types/types.ts

@@ -106,6 +106,7 @@ export enum AccountAuthenticatorVariant {
   SingleKey = 2,
   MultiKey = 3,
   NoAccountAuthenticator = 4,
+  Abstraction = 5,
 }
 
 /**

package/src/utils/helpers.ts

@@ -2,7 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { decode } from "js-base64";
-import { MoveStructId } from "../types";
+import { MoveFunctionId, MoveStructId } from "../types";
+import { AccountAddress } from "../core/accountAddress";
 
 /**
  * Sleep for the specified amount of time in milliseconds.
@@ -175,3 +176,29 @@ export const isEncodedStruct = (
   typeof structObj.account_address === "string" &&
   typeof structObj.module_name === "string" &&
   typeof structObj.struct_name === "string";
+
+/**
+ * Splits a function identifier into its constituent parts: module address, module name, and function name.
+ * This function helps in validating and extracting details from a function identifier string.
+ *
+ * @param functionArg - The function identifier string in the format "moduleAddress::moduleName::functionName".
+ * @returns An object containing the module address, module name, and function name.
+ * @throws Error if the function identifier does not contain exactly three parts.
+ * @group Implementation
+ * @category Transactions
+ */
+export function getFunctionParts(functionArg: MoveFunctionId) {
+  const funcNameParts = functionArg.split("::");
+  if (funcNameParts.length !== 3) {
+    throw new Error(`Invalid function ${functionArg}`);
+  }
+  const moduleAddress = funcNameParts[0];
+  const moduleName = funcNameParts[1];
+  const functionName = funcNameParts[2];
+  return { moduleAddress, moduleName, functionName };
+}
+
+export function isValidFunctionInfo(functionInfo: string): boolean {
+  const parts = functionInfo.split("::");
+  return parts.length === 3 && AccountAddress.isValid({ input: parts[0] }).valid;
+}

package/src/version.ts

@@ -6,4 +6,4 @@
  *
  * hardcoded for now, we would want to have it injected dynamically
  */
-export const VERSION = "1.33.2-sc.0";
+export const VERSION = "1.34.0";

package/dist/common/chunk-IHUCZKG2.js

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var i=Object.defineProperty;var u=Object.getOwnPropertyDescriptor;var m=(e,n,t,r)=>{for(var o=r>1?void 0:r?u(n,t):n,s=e.length-1,a;s>=0;s--)(a=e[s])&&(o=(r?a(n,t,o):a(o))||o);return r&&o&&i(n,t,o),o};var _jsbase64 = require('js-base64');async function p(e){return new Promise(n=>{setTimeout(n,e)})}function f(e){return e instanceof Error?e.message:String(e)}var _=()=>Math.floor(Date.now()/1e3);function S(e){let n=new Date(e*1e3);return n.setMinutes(0),n.setSeconds(0),n.setMilliseconds(0),Math.floor(n.getTime()/1e3)}function x(e){let n=e.replace(/-/g,"+").replace(/_/g,"/"),t=n+"==".substring(0,(3-n.length%3)%3);return _jsbase64.decode.call(void 0, t)}var h=(e,n)=>e*10**n,y= exports.h =(e,n)=>e/10**n,c=e=>{let n="";for(let t=2;t<e.length;t+=2)n+=String.fromCharCode(parseInt(e.substring(t,t+2),16));return n},b= exports.i =e=>{let{account_address:n,module_name:t,struct_name:r}=e,o=c(t),s=c(r);return`${n}::${o}::${s}`},M= exports.j =e=>typeof e=="object"&&!Array.isArray(e)&&e!==null&&"account_address"in e&&"module_name"in e&&"struct_name"in e&&typeof e.account_address=="string"&&typeof e.module_name=="string"&&typeof e.struct_name=="string";exports.a = m; exports.b = p; exports.c = f; exports.d = _; exports.e = S; exports.f = x; exports.g = h; exports.h = y; exports.i = b; exports.j = M;
-//# sourceMappingURL=chunk-IHUCZKG2.js.map

package/dist/common/chunk-IHUCZKG2.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/Users/philip/Documents/General/aptos-ts-sdk/dist/common/chunk-IHUCZKG2.js","../../src/utils/helpers.ts"],"names":["sleep","timeMs","resolve","getErrorMessage","error","nowInSeconds","floorToWholeHour","timestampInSeconds","date","base64UrlDecode","base64Url","base64","paddedBase64","decode","convertAmountFromHumanReadableToOnChain","value","decimal","convertAmountFromOnChainToHumanReadable","hexToAscii","hex","str","n","parseEncodedStruct","structObj","account_address","module_name","struct_name","moduleName","structName"],"mappings":"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","file":"/Users/philip/Documents/General/aptos-ts-sdk/dist/common/chunk-IHUCZKG2.js","sourcesContent":[null,"// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { decode } from \"js-base64\";\nimport { MoveStructId } from \"../types\";\n\n/**\n * Sleep for the specified amount of time in milliseconds.\n * This function can be used to introduce delays in asynchronous operations.\n *\n * @param timeMs - The time in milliseconds to sleep.\n * @group Implementation\n * @category Utils\n */\nexport async function sleep(timeMs: number): Promise<null> {\n  return new Promise((resolve) => {\n    setTimeout(resolve, timeMs);\n  });\n}\n\n/**\n * Get the error message from an unknown error.\n *\n * @param error The error to get the message from\n * @returns The error message\n * @group Implementation\n * @category Utils\n */\nexport function getErrorMessage(error: unknown): string {\n  return error instanceof Error ? error.message : String(error);\n}\n\n/**\n * @group Implementation\n * @category Utils\n */\nexport const nowInSeconds = () => Math.floor(Date.now() / 1000);\n\n/**\n * Floors the given timestamp to the nearest whole hour.\n * This function is useful for normalizing timestamps to hourly intervals.\n *\n * @param timestampInSeconds - The timestamp in seconds to be floored.\n * @group Implementation\n * @category Utils\n */\nexport function floorToWholeHour(timestampInSeconds: number): number {\n  const date = new Date(timestampInSeconds * 1000);\n  // Reset minutes and seconds to zero\n  date.setMinutes(0);\n  date.setSeconds(0);\n  date.setMilliseconds(0);\n  return Math.floor(date.getTime() / 1000);\n}\n\n/**\n * Decodes a base64 URL-encoded string into its original form.\n * This function is useful for converting base64 URL-encoded data back to a readable format.\n *\n * @param base64Url - The base64 URL-encoded string to decode.\n * @returns The decoded string.\n * @group Implementation\n * @category Utils\n */\nexport function base64UrlDecode(base64Url: string): string {\n  // Replace base64url-specific characters\n  const base64 = base64Url.replace(/-/g, \"+\").replace(/_/g, \"/\");\n  // Pad the string with '=' characters if needed\n  const paddedBase64 = base64 + \"==\".substring(0, (3 - (base64.length % 3)) % 3);\n  const decodedString = decode(paddedBase64);\n  return decodedString;\n}\n\n/**\n * Amount is represented in the smallest unit format on chain, this function converts\n * a human-readable amount format to the smallest unit format\n * @example\n * human-readable amount format: 500\n * on chain amount format when decimal is 8: 50000000000\n *\n * @param value The value in human-readable format\n * @param decimal The token decimal\n * @returns The value in the smallest units\n * @group Implementation\n * @category Utils\n */\nexport const convertAmountFromHumanReadableToOnChain = (value: number, decimal: number) => value * 10 ** decimal;\n\n/**\n * Amount is represented in the smallest unit format on chain, this function converts\n * the smallest unit format to a human-readable amount format\n * @example\n * human-readable amount format: 500\n * on chain amount format when decimal is 8: 50000000000\n *\n * @param value The value in human-readable format\n * @param decimal The token decimal\n * @returns The value in the smallest units\n * @group Implementation\n * @category Utils\n */\nexport const convertAmountFromOnChainToHumanReadable = (value: number, decimal: number) => value / 10 ** decimal;\n\n/**\n * Convert a hex string to an ascii string with the `0x` prefix.\n *\n * `0x6170746f735f636f696e` --> `aptos_coin`\n *\n * @param hex The hex string to convert (e.g. `0x6170746f735f636f696e`)\n * @returns The ascii string\n * @group Implementation\n * @category Utils\n */\nconst hexToAscii = (hex: string) => {\n  let str = \"\";\n  for (let n = 2; n < hex.length; n += 2) {\n    str += String.fromCharCode(parseInt(hex.substring(n, n + 2), 16));\n  }\n  return str;\n};\n\n/**\n * Convert an encoded struct to a MoveStructId.\n *\n * @example\n * const structObj = {\n *   account_address: \"0x1\",\n *   module_name: \"0x6170746f735f636f696e\",\n *   struct_name: \"0x4170746f73436f696e\",\n * };\n * // structId is \"0x1::aptos_coin::AptosCoin\"\n * const structId = parseEncodedStruct(structObj);\n *\n * @param structObj The struct with account_address, module_name, and struct_name properties\n * @returns The MoveStructId\n * @group Implementation\n * @category Utils\n */\nexport const parseEncodedStruct = (structObj: {\n  account_address: string;\n  module_name: string;\n  struct_name: string;\n}): MoveStructId => {\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  const { account_address, module_name, struct_name } = structObj;\n  const moduleName = hexToAscii(module_name);\n  const structName = hexToAscii(struct_name);\n  return `${account_address}::${moduleName}::${structName}`;\n};\n\n/**\n * Determines whether the given object is an encoded struct type with the following properties:\n * - account_address: string\n * - module_name: string\n * - struct_name: string\n *\n * @param structObj The object to check\n * @returns Whether the object is an encoded struct type\n * @group Implementation\n * @category Utils\n */\nexport const isEncodedStruct = (\n  structObj: any,\n): structObj is {\n  account_address: string;\n  module_name: string;\n  struct_name: string;\n} =>\n  typeof structObj === \"object\" &&\n  !Array.isArray(structObj) &&\n  structObj !== null &&\n  \"account_address\" in structObj &&\n  \"module_name\" in structObj &&\n  \"struct_name\" in structObj &&\n  typeof structObj.account_address === \"string\" &&\n  typeof structObj.module_name === \"string\" &&\n  typeof structObj.struct_name === \"string\";\n"]}