@aptos-labs/ts-sdk 1.35.0 → 1.36.0-zeta.0

package/src/internal/transactionSubmission.ts

@@ -7,13 +7,12 @@
  */
 
 import { AptosConfig } from "../api/aptosConfig";
-import { Deserializer, MoveVector, U8 } from "../bcs";
+import { Deserializer, MoveVector } from "../bcs";
 import { postAptosFullNode } from "../client";
 import { Account, AbstractKeylessAccount, isKeylessSigner } from "../account";
 import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
-import { FederatedKeylessPublicKey, KeylessPublicKey, KeylessSignature, PrivateKeyInput } from "../core/crypto";
+import { FederatedKeylessPublicKey, KeylessPublicKey, KeylessSignature } from "../core/crypto";
 import { AccountAuthenticator } from "../transactions/authenticator/account";
-import { RotationProofChallenge } from "../transactions/instances/rotationProofChallenge";
 import {
   buildTransaction,
   generateTransactionPayload,
@@ -32,9 +31,8 @@ import {
   AnyTransactionPayloadInstance,
   EntryFunctionABI,
 } from "../transactions/types";
-import { getInfo } from "./account";
-import { UserTransactionResponse, PendingTransactionResponse, MimeType, HexInput, TransactionResponse } from "../types";
-import { SignedTransaction, TypeTagU8, TypeTagVector, generateSigningMessageForTransaction } from "../transactions";
+import { UserTransactionResponse, PendingTransactionResponse, MimeType, HexInput } from "../types";
+import { SignedTransaction, TypeTagVector, generateSigningMessageForTransaction } from "../transactions";
 import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
 import { MultiAgentTransaction } from "../transactions/instances/multiAgentTransaction";
 
@@ -444,78 +442,3 @@ export async function publicPackageTransaction(args: {
     options,
   });
 }
-
-const rotateAuthKeyAbi: EntryFunctionABI = {
-  typeParameters: [],
-  parameters: [
-    new TypeTagU8(),
-    TypeTagVector.u8(),
-    new TypeTagU8(),
-    TypeTagVector.u8(),
-    TypeTagVector.u8(),
-    TypeTagVector.u8(),
-  ],
-};
-
-/**
- * Rotates the authentication key for a given account, allowing for enhanced security and management of account access.
- *
- * @param args - The arguments for rotating the authentication key.
- * @param args.aptosConfig - The configuration settings for the Aptos network.
- * @param args.fromAccount - The account from which the authentication key will be rotated.
- * @param args.toNewPrivateKey - The new private key that will be associated with the account.
- *
- * @remarks
- * This function requires the current authentication key and the new private key to sign a challenge that validates the rotation.
- *
- * TODO: Need to refactor and move this function out of transactionSubmission.
- * @group Implementation
- */
-export async function rotateAuthKey(args: {
-  aptosConfig: AptosConfig;
-  fromAccount: Account;
-  toNewPrivateKey: PrivateKeyInput;
-}): Promise<TransactionResponse> {
-  const { aptosConfig, fromAccount, toNewPrivateKey } = args;
-  const accountInfo = await getInfo({
-    aptosConfig,
-    accountAddress: fromAccount.accountAddress,
-  });
-
-  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,
-    data: {
-      function: "0x1::account::rotate_authentication_key",
-      functionArguments: [
-        new U8(fromAccount.signingScheme), // from scheme
-        MoveVector.U8(fromAccount.publicKey.toUint8Array()),
-        new U8(newAccount.signingScheme), // to scheme
-        MoveVector.U8(newAccount.publicKey.toUint8Array()),
-        MoveVector.U8(proofSignedByCurrentPrivateKey.toUint8Array()),
-        MoveVector.U8(proofSignedByNewPrivateKey.toUint8Array()),
-      ],
-      abi: rotateAuthKeyAbi,
-    },
-  });
-  return signAndSubmitTransaction({
-    aptosConfig,
-    signer: fromAccount,
-    transaction: rawTxn,
-  });
-}

package/src/internal/utils/index.ts

@@ -0,0 +1,4 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+export * from "./utils";

package/src/internal/utils/utils.ts

@@ -0,0 +1,116 @@
+import { AccountAddress, AccountAddressInput } from "../../core/accountAddress";
+import { MoveModuleBytecode, LedgerVersionArg, PaginationArgs, AccountData } from "../../types/types";
+import { AptosConfig } from "../../api/aptosConfig";
+import { getAptosFullNode, paginateWithObfuscatedCursor } from "../../client";
+import { memoizeAsync } from "../../utils/memoize";
+
+/**
+ * Retrieves the modules associated with a specified account address.
+ *
+ * @param args - The arguments for retrieving modules.
+ * @param args.aptosConfig - The configuration for connecting to the Aptos blockchain.
+ * @param args.accountAddress - The address of the account whose modules are to be retrieved.
+ * @param args.options - Optional parameters for pagination and ledger version.
+ * @param args.options.limit - The maximum number of modules to retrieve (default is 1000).
+ * @param args.options.offset - The starting point for pagination.  Note, this is obfuscated and is not an index.
+ * @param args.options.ledgerVersion - The specific ledger version to query.
+ * @group Implementation
+ */
+export async function getModules(args: {
+  aptosConfig: AptosConfig;
+  accountAddress: AccountAddressInput;
+  options?: PaginationArgs & LedgerVersionArg;
+}): Promise<MoveModuleBytecode[]> {
+  const { aptosConfig, accountAddress, options } = args;
+  return paginateWithObfuscatedCursor<{}, MoveModuleBytecode[]>({
+    aptosConfig,
+    originMethod: "getModules",
+    path: `accounts/${AccountAddress.from(accountAddress).toString()}/modules`,
+    params: {
+      ledger_version: options?.ledgerVersion,
+      offset: options?.offset,
+      limit: options?.limit ?? 1000,
+    },
+  });
+}
+
+/**
+ * Retrieves account information for a specified account address.
+ *
+ * @param args - The arguments for retrieving account information.
+ * @param args.aptosConfig - The configuration object for Aptos.
+ * @param args.accountAddress - The address of the account to retrieve information for.
+ * @group Implementation
+ */
+export async function getInfo(args: {
+  aptosConfig: AptosConfig;
+  accountAddress: AccountAddressInput;
+}): Promise<AccountData> {
+  const { aptosConfig, accountAddress } = args;
+  const { data } = await getAptosFullNode<{}, AccountData>({
+    aptosConfig,
+    originMethod: "getInfo",
+    path: `accounts/${AccountAddress.from(accountAddress).toString()}`,
+  });
+  return data;
+}
+
+/**
+ * Queries for a move module given an account address and module name.
+ * This function can help you retrieve the module's ABI and other relevant information.
+ *
+ * @param args - The arguments for retrieving the module.
+ * @param args.aptosConfig - The configuration for the Aptos client.
+ * @param args.accountAddress - The account address in hex-encoded 32 byte format.
+ * @param args.moduleName - The name of the module to retrieve.
+ * @param args.options - Optional parameters for the request.
+ * @param args.options.ledgerVersion - Specifies the ledger version of transactions. By default, the latest version will be used.
+ * @returns The move module.
+ * @group Implementation
+ */
+export async function getModule(args: {
+  aptosConfig: AptosConfig;
+  accountAddress: AccountAddressInput;
+  moduleName: string;
+  options?: LedgerVersionArg;
+}): Promise<MoveModuleBytecode> {
+  // We don't memoize the account module by ledger version, as it's not a common use case, this would be handled
+  // by the developer directly
+  if (args.options?.ledgerVersion !== undefined) {
+    return getModuleInner(args);
+  }
+
+  return memoizeAsync(
+    async () => getModuleInner(args),
+    `module-${args.accountAddress}-${args.moduleName}`,
+    1000 * 60 * 5, // 5 minutes
+  )();
+}
+
+/**
+ * Retrieves the bytecode of a specified module from a given account address.
+ *
+ * @param args - The parameters for retrieving the module bytecode.
+ * @param args.aptosConfig - The configuration for connecting to the Aptos network.
+ * @param args.accountAddress - The address of the account from which to retrieve the module.
+ * @param args.moduleName - The name of the module to retrieve.
+ * @param args.options - Optional parameters for specifying the ledger version.
+ * @param args.options.ledgerVersion - The specific ledger version to query.
+ * @group Implementation
+ */
+async function getModuleInner(args: {
+  aptosConfig: AptosConfig;
+  accountAddress: AccountAddressInput;
+  moduleName: string;
+  options?: LedgerVersionArg;
+}): Promise<MoveModuleBytecode> {
+  const { aptosConfig, accountAddress, moduleName, options } = args;
+
+  const { data } = await getAptosFullNode<{}, MoveModuleBytecode>({
+    aptosConfig,
+    originMethod: "getModule",
+    path: `accounts/${AccountAddress.from(accountAddress).toString()}/module/${moduleName}`,
+    params: { ledger_version: options?.ledgerVersion },
+  });
+  return data;
+}

package/src/transactions/scriptComposer/index.ts

@@ -5,9 +5,9 @@ import { ScriptComposerWasm } from "@aptos-labs/script-composer-pack";
 import { AptosApiType, getFunctionParts } from "../../utils";
 import { AptosConfig } from "../../api/aptosConfig";
 import { InputBatchedFunctionData } from "../types";
-import { fetchMoveFunctionAbi, standardizeTypeTags } from "../transactionBuilder";
+import { standardizeTypeTags } from "../transactionBuilder";
 import { CallArgument } from "../../types";
-import { convertCallArgument } from "../transactionBuilder/remoteAbi";
+import { convertArgument, fetchModuleAbi } from "../transactionBuilder/remoteAbi";
 
 /**
  * A wrapper class around TransactionComposer, which is a WASM library compiled
@@ -58,19 +58,34 @@ export class AptosScriptComposer {
 
     // Load the calling type arguments into the loader.
     if (input.typeArguments !== undefined) {
-      await Promise.all(input.typeArguments.map((typeTag) => this.builder.load_type_tag(nodeUrl, typeTag.toString())));
+      for (const typeArgument of input.typeArguments) {
+        await this.builder.load_type_tag(nodeUrl, typeArgument.toString());
+      }
     }
     const typeArguments = standardizeTypeTags(input.typeArguments);
-    const functionAbi = await fetchMoveFunctionAbi(moduleAddress, moduleName, functionName, this.config);
+    const moduleAbi = await fetchModuleAbi(moduleAddress, moduleName, this.config);
+    if (!moduleAbi) {
+      throw new Error(`Could not find module ABI for '${moduleAddress}::${moduleName}'`);
+    }
+
     // Check the type argument count against the ABI
-    if (typeArguments.length !== functionAbi.typeParameters.length) {
+    const functionAbi = moduleAbi?.exposed_functions.find((func) => func.name === functionName);
+    if (!functionAbi) {
+      throw new Error(`Could not find function ABI for '${moduleAddress}::${moduleName}::${functionName}'`);
+    }
+
+    if (typeArguments.length !== functionAbi.generic_type_params.length) {
       throw new Error(
-        `Type argument count mismatch, expected ${functionAbi.typeParameters.length}, received ${typeArguments.length}`,
+        `Type argument count mismatch, expected ${functionAbi?.generic_type_params.length}, received ${typeArguments.length}`,
       );
     }
 
     const functionArguments: CallArgument[] = input.functionArguments.map((arg, i) =>
-      convertCallArgument(arg, functionName, functionAbi, i, typeArguments),
+      arg instanceof CallArgument
+        ? arg
+        : CallArgument.newBytes(
+            convertArgument(functionName, moduleAbi, arg, i, typeArguments, { allowUnknownStructs: true }).bcsToBytes(),
+          ),
     );
 
     return this.builder.add_batched_call(

package/src/transactions/transactionBuilder/remoteAbi.ts

@@ -23,7 +23,7 @@ import {
   FunctionABI,
   TypeArgument,
 } from "../types";
-import { Bool, MoveOption, MoveString, MoveVector, U128, U16, U256, U32, U64, U8 } from "../../bcs";
+import { Bool, FixedBytes, MoveOption, MoveString, MoveVector, U128, U16, U256, U32, U64, U8 } from "../../bcs";
 import { AccountAddress } from "../../core";
 import { getModule } from "../../internal/account";
 import {
@@ -45,7 +45,7 @@ import {
   throwTypeMismatch,
   convertNumber,
 } from "./helpers";
-import { CallArgument, MoveFunction } from "../../types";
+import { CallArgument, MoveFunction, MoveModule } from "../../types";
 
 const TEXT_ENCODER = new TextEncoder();
 
@@ -69,6 +69,24 @@ export function standardizeTypeTags(typeArguments?: Array<TypeArgument>): Array<
   );
 }
 
+/**
+ * Fetches the ABI of a specified module from the on-chain module ABI.
+ *
+ * @param moduleAddress - The address of the module from which to fetch the ABI.
+ * @param moduleName - The name of the module containing the ABI.
+ * @param aptosConfig - The configuration settings for Aptos.
+ * @group Implementation
+ * @category Transactions
+ */
+export async function fetchModuleAbi(
+  moduleAddress: string,
+  moduleName: string,
+  aptosConfig: AptosConfig,
+): Promise<MoveModule | undefined> {
+  const moduleBytecode = await getModule({ aptosConfig, accountAddress: moduleAddress, moduleName });
+  return moduleBytecode.abi;
+}
+
 /**
  * Fetches the ABI of a specified function from the on-chain module ABI. This function allows you to access the details of a
  * specific function within a module.
@@ -86,22 +104,13 @@ export async function fetchFunctionAbi(
   functionName: string,
   aptosConfig: AptosConfig,
 ): Promise<MoveFunction | undefined> {
-  // This fetch from the API is currently cached
-  const module = await getModule({ aptosConfig, accountAddress: moduleAddress, moduleName });
-
-  if (module.abi) {
-    return module.abi.exposed_functions.find((func) => func.name === functionName);
-  }
-
-  return undefined;
+  const moduleAbi = await fetchModuleAbi(moduleAddress, moduleName, aptosConfig);
+  if (!moduleAbi) throw new Error(`Could not find module ABI for '${moduleAddress}::${moduleName}'`);
+  return moduleAbi.exposed_functions.find((func) => func.name === functionName);
 }
 
 /**
- * Fetches a function ABI from the on-chain module ABI.  It doesn't validate whether it's a view or entry function.
- * @param moduleAddress
- * @param moduleName
- * @param functionName
- * @param aptosConfig
+ * @deprecated Use `fetchFunctionAbi` instead and manually parse the type tags.
  */
 export async function fetchMoveFunctionAbi(
   moduleAddress: string,
@@ -220,15 +229,14 @@ export async function fetchViewFunctionAbi(
 }
 
 /**
- * Converts a entry function argument into CallArgument, if necessary.
- * This function checks the provided argument against the expected parameter type and converts it accordingly.
+ * @deprecated Handle this inline
  *
- * @param functionName - The name of the function for which the argument is being converted.
- * @param functionAbi - The ABI (Application Binary Interface) of the function, which defines its parameters.
- * @param argument - The argument to be converted, which can be of various types. If the argument is already
- *                   CallArgument returned from TransactionComposer it would be returned immediately.
- * @param position - The index of the argument in the function's parameter list.
- * @param genericTypeParams - An array of type tags for any generic type parameters.
+ * @example
+ * ```typescript
+ * const callArgument = argument instanceof CallArgument ? argument : CallArgument.newBytes(
+ *   convertArgument(functionName, functionAbi, argument, position, genericTypeParams).bcsToBytes()
+ * );
+ * ```
  */
 export function convertCallArgument(
   argument: CallArgument | EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes,
@@ -250,27 +258,54 @@ export function convertCallArgument(
  * This function checks the provided argument against the expected parameter type and converts it accordingly.
  *
  * @param functionName - The name of the function for which the argument is being converted.
- * @param functionAbi - The ABI (Application Binary Interface) of the function, which defines its parameters.
+ * @param functionAbiOrModuleAbi - The ABI (Application Binary Interface) of the function, which defines its parameters.
  * @param arg - The argument to be converted, which can be of various types.
  * @param position - The index of the argument in the function's parameter list.
  * @param genericTypeParams - An array of type tags for any generic type parameters.
+ * @param options - Options for the conversion process.
+ * @param options.allowUnknownStructs - If true, unknown structs will be allowed and converted to a `FixedBytes`.
  * @group Implementation
  * @category Transactions
  */
 export function convertArgument(
   functionName: string,
-  functionAbi: FunctionABI,
+  functionAbiOrModuleAbi: MoveModule | FunctionABI,
   arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes,
   position: number,
   genericTypeParams: Array<TypeTag>,
+  options?: { allowUnknownStructs?: boolean },
 ) {
-  // Ensure not too many arguments
-  if (position >= functionAbi.parameters.length) {
-    throw new Error(`Too many arguments for '${functionName}', expected ${functionAbi.parameters.length}`);
+  let param: TypeTag;
+
+  if ("exposed_functions" in functionAbiOrModuleAbi) {
+    const functionAbi = functionAbiOrModuleAbi.exposed_functions.find((func) => func.name === functionName);
+    if (!functionAbi) {
+      throw new Error(
+        `Could not find function ABI for '${functionAbiOrModuleAbi.address}::${functionAbiOrModuleAbi.name}::${functionName}'`,
+      );
+    }
+
+    if (position >= functionAbi.params.length) {
+      throw new Error(`Too many arguments for '${functionName}', expected ${functionAbi.params.length}`);
+    }
+
+    param = parseTypeTag(functionAbi.params[position], { allowGenerics: true });
+  } else {
+    if (position >= functionAbiOrModuleAbi.parameters.length) {
+      throw new Error(`Too many arguments for '${functionName}', expected ${functionAbiOrModuleAbi.parameters.length}`);
+    }
+
+    param = functionAbiOrModuleAbi.parameters[position];
   }
 
-  const param = functionAbi.parameters[position];
-  return checkOrConvertArgument(arg, param, position, genericTypeParams);
+  return checkOrConvertArgument(
+    arg,
+    param,
+    position,
+    genericTypeParams,
+    "exposed_functions" in functionAbiOrModuleAbi ? functionAbiOrModuleAbi : undefined,
+    options,
+  );
 }
 
 /**
@@ -289,6 +324,8 @@ export function checkOrConvertArgument(
   param: TypeTag,
   position: number,
   genericTypeParams: Array<TypeTag>,
+  moduleAbi?: MoveModule,
+  options?: { allowUnknownStructs?: boolean },
 ) {
   // If the argument is bcs encoded, we can just use it directly
   if (isEncodedEntryFunctionArgument(arg)) {
@@ -301,6 +338,8 @@ export function checkOrConvertArgument(
      * @param typeArgs - The expected type arguments.
      * @param arg - The argument to be checked.
      * @param position - The position of the argument in the context of the check.
+     * @param moduleAbi - The ABI of the module containing the function, used for type checking.
+     *                    This will typically have information about structs, enums, and other types.
      * @group Implementation
      * @category Transactions
      */
@@ -309,7 +348,7 @@ export function checkOrConvertArgument(
   }
 
   // If it is not BCS encoded, we will need to convert it with the ABI
-  return parseArg(arg, param, position, genericTypeParams);
+  return parseArg(arg, param, position, genericTypeParams, moduleAbi, options);
 }
 
 /**
@@ -321,6 +360,10 @@ export function checkOrConvertArgument(
  * @param param - The type tag that defines the expected type of the argument.
  * @param position - The position of the argument in the function call, used for error reporting.
  * @param genericTypeParams - An array of type tags for generic type parameters, used when the parameter type is generic.
+ * @param moduleAbi - The ABI of the module containing the function, used for type checking.
+ *                    This will typically have information about structs, enums, and other types.
+ * @param options - Options for the conversion process.
+ * @param options.allowUnknownStructs - If true, unknown structs will be allowed and converted to a `FixedBytes`.
  * @group Implementation
  * @category Transactions
  */
@@ -329,6 +372,8 @@ function parseArg(
   param: TypeTag,
   position: number,
   genericTypeParams: Array<TypeTag>,
+  moduleAbi?: MoveModule,
+  options?: { allowUnknownStructs?: boolean },
 ): EntryFunctionArgumentTypes {
   if (param.isBool()) {
     if (isBool(arg)) {
@@ -403,7 +448,7 @@ function parseArg(
       throw new Error(`Generic argument ${param.toString()} is invalid for argument ${position}`);
     }
 
-    return checkOrConvertArgument(arg, genericTypeParams[genericIndex], position, genericTypeParams);
+    return checkOrConvertArgument(arg, genericTypeParams[genericIndex], position, genericTypeParams, moduleAbi);
   }
 
   // We have to special case some vectors for Vector<u8>
@@ -433,7 +478,9 @@ function parseArg(
     // TODO: Support Uint16Array, Uint32Array, BigUint64Array?
 
     if (Array.isArray(arg)) {
-      return new MoveVector(arg.map((item) => checkOrConvertArgument(item, param.value, position, genericTypeParams)));
+      return new MoveVector(
+        arg.map((item) => checkOrConvertArgument(item, param.value, position, genericTypeParams, moduleAbi)),
+      );
     }
 
     throw new Error(`Type mismatch for argument ${position}, type '${param.toString()}'`);
@@ -454,6 +501,13 @@ function parseArg(
       }
       throwTypeMismatch("string | AccountAddress", position);
     }
+    // Handle known enum types from Aptos framework
+    if (param.isDelegationKey() || param.isRateLimiter()) {
+      if (arg instanceof Uint8Array) {
+        return new FixedBytes(arg);
+      }
+      throwTypeMismatch("Uint8Array", position);
+    }
 
     if (param.isOption()) {
       if (isEmptyOption(arg)) {
@@ -490,7 +544,25 @@ function parseArg(
         return new MoveOption<MoveString>(null);
       }
 
-      return new MoveOption(checkOrConvertArgument(arg, param.value.typeArgs[0], position, genericTypeParams));
+      return new MoveOption(
+        checkOrConvertArgument(arg, param.value.typeArgs[0], position, genericTypeParams, moduleAbi),
+      );
+    }
+
+    // We are assuming that fieldless structs are enums, and therefore we cannot typecheck any further due
+    // to limited information from the ABI. This does not work for structs on other modules.
+    const structDefinition = moduleAbi?.structs.find((s) => s.name === param.value.name.identifier);
+    if (structDefinition?.fields.length === 0 && arg instanceof Uint8Array) {
+      return new FixedBytes(arg);
+    }
+
+    if (arg instanceof Uint8Array && options?.allowUnknownStructs) {
+      // eslint-disable-next-line no-console
+      console.warn(
+        // eslint-disable-next-line max-len
+        `Unsupported struct input type for argument ${position}. Continuing since 'allowUnknownStructs' is enabled.`,
+      );
+      return new FixedBytes(arg);
     }
 
     throw new Error(`Unsupported struct input type for argument ${position}, type '${param.toString()}'`);

package/src/transactions/transactionBuilder/transactionBuilder.ts

@@ -20,7 +20,7 @@ import {
   MultiKeySignature,
 } from "../../core/crypto";
 import { Ed25519PublicKey, Ed25519Signature } from "../../core/crypto/ed25519";
-import { getInfo } from "../../internal/account";
+import { getInfo } from "../../internal/utils";
 import { getLedgerInfo } from "../../internal/general";
 import { getGasPriceEstimation } from "../../internal/transaction";
 import { NetworkToChainId } from "../../utils/apiEndpoints";
@@ -638,7 +638,12 @@ export function getAuthenticatorForSimulation(publicKey?: PublicKey) {
     return new AccountAuthenticatorMultiKey(
       accountPublicKey,
       new MultiKeySignature({
-        signatures: accountPublicKey.publicKeys.map(() => new AnySignature(invalidSignature)),
+        signatures: accountPublicKey.publicKeys.map((pubKey) => {
+          if (KeylessPublicKey.isInstance(pubKey.publicKey) || FederatedKeylessPublicKey.isInstance(pubKey.publicKey)) {
+            return new AnySignature(KeylessSignature.getSimulationSignature());
+          }
+          return new AnySignature(invalidSignature);
+        }),
         bitmap: accountPublicKey.createBitmap({
           bits: Array(accountPublicKey.publicKeys.length)
             .fill(0)

package/src/transactions/typeTag/index.ts

@@ -639,6 +639,28 @@ export class TypeTagStruct extends TypeTag {
   isObject(): boolean {
     return this.isTypeTag(AccountAddress.ONE, "object", "Object");
   }
+
+  /**
+   * Checks if the provided value is a 'DelegationKey' for permissioned signers.
+   *
+   * @returns {boolean} Returns true if the value is a DelegationKey, otherwise false.
+   * @group Implementation
+   * @category Transactions
+   */
+  isDelegationKey(): boolean {
+    return this.isTypeTag(AccountAddress.ONE, "permissioned_delegation", "DelegationKey");
+  }
+
+  /**
+   * Checks if the provided value is of type `RateLimiter`.
+   *
+   * @returns {boolean} Returns true if the value is a RateLimiter, otherwise false.
+   * @group Implementation
+   * @category Transactions
+   */
+  isRateLimiter(): boolean {
+    return this.isTypeTag(AccountAddress.ONE, "rate_limiter", "RateLimiter");
+  }
 }
 
 /**

package/src/types/keyless.ts

@@ -58,7 +58,7 @@ export type KeylessConfigurationResponse = {
   max_jwt_header_b64_bytes: number;
   max_signatures_per_txn: number;
   override_aud_vals: string[];
-  training_wheels_pubkey: { vec: string[] };
+  training_wheels_pubkey: { vec: [string] };
 };
 
 /**

package/src/utils/helpers.ts

@@ -72,6 +72,17 @@ export function base64UrlDecode(base64Url: string): string {
   return decodedString;
 }
 
+export function base64UrlToBytes(base64Url: string): Uint8Array {
+  // Convert Base64Url to Base64
+  let base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/");
+  // Add padding if needed
+  while (base64.length % 4 !== 0) {
+    base64 += "=";
+  }
+  // Use Buffer to convert base64 to Uint8Array
+  return new Uint8Array(Buffer.from(base64, "base64"));
+}
+
 /**
  * Amount is represented in the smallest unit format on chain, this function converts
  * a human-readable amount format to the smallest unit format
@@ -198,7 +209,29 @@ export function getFunctionParts(functionArg: MoveFunctionId) {
   return { moduleAddress, moduleName, functionName };
 }
 
+/**
+ * Validates the provided function information.
+ *
+ * @param functionInfo - The function information to validate.
+ * @returns Whether the function information is valid.
+ * @group Implementation
+ * @category Utils
+ */
 export function isValidFunctionInfo(functionInfo: string): boolean {
   const parts = functionInfo.split("::");
   return parts.length === 3 && AccountAddress.isValid({ input: parts[0] }).valid;
 }
+
+/**
+ * Truncates the provided wallet address at the middle with an ellipsis.
+ *
+ * @param address - The wallet address to truncate.
+ * @param start - The number of characters to show at the beginning of the address.
+ * @param end - The number of characters to show at the end of the address.
+ * @returns The truncated address.
+ * @group Implementation
+ * @category Utils
+ */
+export function truncateAddress(address: string, start: number = 6, end: number = 5) {
+  return `${address.slice(0, start)}...${address.slice(-end)}`;
+}

package/src/version.ts

@@ -6,4 +6,4 @@
  *
  * hardcoded for now, we would want to have it injected dynamically
  */
-export const VERSION = "1.35.0";
+export const VERSION = "1.36.0";