@aptos-labs/ts-sdk 0.0.7 → 0.0.8

package/src/api/general.ts

@@ -8,6 +8,7 @@ import {
   getChainTopUserTransactions,
   getIndexerLastSuccessVersion,
   getLedgerInfo,
+  getProcessorStatus,
   getTableItem,
   queryIndexer,
   view,
@@ -16,13 +17,15 @@ import {
   AnyNumber,
   Block,
   GetChainTopUserTransactionsResponse,
+  GetProcessorStatusResponse,
   GraphqlQuery,
   LedgerInfo,
-  LedgerVersion,
+  LedgerVersionArg,
   MoveValue,
   TableItemRequest,
   InputViewRequestData,
 } from "../types";
+import { ProcessorType } from "../utils/const";
 
 /**
  * A class to query all `General` Aptos related queries
@@ -114,7 +117,7 @@ export class General {
    *
    * @returns Table item value rendered in JSON
    */
-  async getTableItem<T>(args: { handle: string; data: TableItemRequest; options?: LedgerVersion }): Promise<T> {
+  async getTableItem<T>(args: { handle: string; data: TableItemRequest; options?: LedgerVersionArg }): Promise<T> {
     return getTableItem<T>({ aptosConfig: this.config, ...args });
   }
 
@@ -133,7 +136,10 @@ export class General {
    *
    * @returns an array of Move values
    */
-  async view<T extends Array<MoveValue>>(args: { payload: InputViewRequestData; options?: LedgerVersion }): Promise<T> {
+  async view<T extends Array<MoveValue>>(args: {
+    payload: InputViewRequestData;
+    options?: LedgerVersionArg;
+  }): Promise<T> {
     return view<T>({ aptosConfig: this.config, ...args });
   }
 
@@ -185,4 +191,14 @@ export class General {
   async getIndexerLastSuccessVersion(): Promise<number> {
     return getIndexerLastSuccessVersion({ aptosConfig: this.config });
   }
+
+  /**
+   * Query the processor status for a specific processor type.
+   *
+   * @param processorType The processor type to query
+   * @returns
+   */
+  async getProcessorStatus(processorType: ProcessorType): Promise<GetProcessorStatusResponse[0]> {
+    return getProcessorStatus({ aptosConfig: this.config, processorType });
+  }
 }

package/src/api/staking.ts

@@ -1,45 +1,57 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { AptosConfig } from "./aptosConfig";
 import {
   getDelegatedStakingActivities,
   getNumberOfDelegators,
   getNumberOfDelegatorsForAllPools,
 } from "../internal/staking";
-import { GetDelegatedStakingActivitiesResponse, GetNumberOfDelegatorsResponse, OrderBy } from "../types";
+import { AnyNumber, GetDelegatedStakingActivitiesResponse, GetNumberOfDelegatorsResponse, OrderByArg } from "../types";
 import { AccountAddressInput } from "../core";
+import { ProcessorType } from "../utils/const";
+import { AptosConfig } from "./aptosConfig";
+import { waitForIndexerOnVersion } from "./utils";
 
 /**
  * A class to query all `Staking` related queries on Aptos.
  */
 export class Staking {
-  readonly config: AptosConfig;
-
-  constructor(config: AptosConfig) {
-    this.config = config;
-  }
+  constructor(readonly config: AptosConfig) {}
 
   /**
    * Queries current number of delegators in a pool.  Throws an error if the pool is not found.
    *
    * @param args.poolAddress Pool address
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
    * @returns The number of delegators for the given pool
    */
-  async getNumberOfDelegators(args: { poolAddress: AccountAddressInput }): Promise<number> {
+  async getNumberOfDelegators(args: {
+    poolAddress: AccountAddressInput;
+    minimumLedgerVersion?: AnyNumber;
+  }): Promise<number> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args?.minimumLedgerVersion,
+      processorTypes: [ProcessorType.STAKE_PROCESSOR],
+    });
     return getNumberOfDelegators({ aptosConfig: this.config, ...args });
   }
 
   /**
    * Queries current number of delegators in a pool.  Throws an error if the pool is not found.
    *
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
    * @returns GetNumberOfDelegatorsForAllPoolsResponse response type
    */
   async getNumberOfDelegatorsForAllPools(args?: {
-    options?: {
-      orderBy?: OrderBy<GetNumberOfDelegatorsResponse[0]>;
-    };
+    minimumLedgerVersion?: AnyNumber;
+    options?: OrderByArg<GetNumberOfDelegatorsResponse[0]>;
   }): Promise<GetNumberOfDelegatorsResponse> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args?.minimumLedgerVersion,
+      processorTypes: [ProcessorType.STAKE_PROCESSOR],
+    });
     return getNumberOfDelegatorsForAllPools({ aptosConfig: this.config, ...args });
   }
 
@@ -48,12 +60,19 @@ export class Staking {
    *
    * @param args.delegatorAddress Delegator address
    * @param args.poolAddress Pool address
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
    * @returns GetDelegatedStakingActivitiesResponse response type
    */
   async getDelegatedStakingActivities(args: {
     delegatorAddress: AccountAddressInput;
     poolAddress: AccountAddressInput;
+    minimumLedgerVersion?: AnyNumber;
   }): Promise<GetDelegatedStakingActivitiesResponse> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args?.minimumLedgerVersion,
+      processorTypes: [ProcessorType.STAKE_PROCESSOR],
+    });
     return getDelegatedStakingActivities({ aptosConfig: this.config, ...args });
   }
 }

package/src/api/transaction.ts

@@ -12,12 +12,15 @@ import {
 } from "../internal/transaction";
 import {
   AnyNumber,
+  CommittedTransactionResponse,
   GasEstimation,
   HexInput,
   PaginationArgs,
   TransactionResponse,
   WaitForTransactionOptions,
 } from "../types";
+import { getSigningMessage } from "../internal/transactionSubmission";
+import { AnyRawTransaction } from "../transactions";
 
 export class Transaction {
   readonly config: AptosConfig;
@@ -112,7 +115,7 @@ export class Transaction {
   async waitForTransaction(args: {
     transactionHash: HexInput;
     options?: WaitForTransactionOptions;
-  }): Promise<TransactionResponse> {
+  }): Promise<CommittedTransactionResponse> {
     return waitForTransaction({
       aptosConfig: this.config,
       ...args,
@@ -139,4 +142,16 @@ export class Transaction {
       aptosConfig: this.config,
     });
   }
+
+  /**
+   * Returns a signing message for a transaction.
+   *
+   * This allows a user to sign a transaction using their own preferred signing method, and
+   * then submit it to the network.
+   * @param args.transaction A raw transaction for signing elsewhere
+   */
+  // eslint-disable-next-line class-methods-use-this
+  getSigningMessage(args: { transaction: AnyRawTransaction }): Uint8Array {
+    return getSigningMessage(args);
+  }
 }

package/src/api/transactionSubmission.ts

@@ -3,9 +3,15 @@
 
 import { AptosConfig } from "./aptosConfig";
 import { Account, AccountAddressInput, PrivateKey } from "../core";
-import { AnyRawTransaction, SingleSignerTransaction, InputGenerateTransactionOptions } from "../transactions/types";
+import {
+  AnyRawTransaction,
+  SingleSignerTransaction,
+  InputGenerateTransactionOptions,
+  InputGenerateTransactionPayloadData,
+} from "../transactions/types";
 import { PendingTransactionResponse, HexInput, TransactionResponse } from "../types";
 import { publicPackageTransaction, rotateAuthKey, signAndSubmitTransaction } from "../internal/transactionSubmission";
+import { TransactionWorker } from "../transactions/management";
 
 export class TransactionSubmission {
   readonly config: AptosConfig;
@@ -14,6 +20,42 @@ export class TransactionSubmission {
     this.config = config;
   }
 
+  /**
+   * Batch transactions for a single account.
+   *
+   * This function uses a transaction worker that receives payloads to be processed
+   * and submitted to chain.
+   * Note that this process is best for submitting multiple transactions that
+   * dont rely on each other, i.e batch funds, batch token mints, etc.
+   *
+   * If any worker failure, the functions throws an error.
+   *
+   * @param args.sender The sender account to sign and submit the transaction
+   * @param args.data An array of transaction payloads
+   * @param args.options optional. Transaction generation configurations (excluding accountSequenceNumber)
+   *
+   * @return void. Throws if any error
+   */
+  async batchTransactionsForSingleAccount(args: {
+    sender: Account;
+    data: InputGenerateTransactionPayloadData[];
+    options?: Omit<InputGenerateTransactionOptions, "accountSequenceNumber">;
+  }): Promise<void> {
+    try {
+      const { sender, data, options } = args;
+      const transactionWorker = new TransactionWorker(this.config, sender);
+
+      transactionWorker.start();
+
+      for (const d of data) {
+        /* eslint-disable no-await-in-loop */
+        await transactionWorker.push(d, options);
+      }
+    } catch (error: any) {
+      throw new Error(`failed to submit transactions with error: ${error}`);
+    }
+  }
+
   /**
    * Sign and submit a single signer transaction to chain
    *

package/src/api/utils.ts

@@ -0,0 +1,37 @@
+import { waitForIndexer } from "../internal/transaction";
+import { ProcessorType } from "../utils";
+import { AptosConfig } from "./aptosConfig";
+import { AnyNumber } from "../types";
+
+/**
+ * Utility function to handle optional waiting on indexer for APIs
+ *
+ * This is purposely placed here to not expose this internal function.
+ * @param args
+ */
+export async function waitForIndexerOnVersion(args: {
+  config: AptosConfig;
+  minimumLedgerVersion?: AnyNumber;
+  processorTypes: Array<ProcessorType>;
+}) {
+  if (args.minimumLedgerVersion !== undefined) {
+    // eslint-disable-next-line no-restricted-syntax
+
+    // Collect all of the promises to wait at the same time
+    // TODO(greg): This needs to be refactored to be handled at the query time.  It involves rewriting
+    // a bunch of the logic for wait for indexer
+    const promises: Array<Promise<void>> = [];
+    // eslint-disable-next-line no-restricted-syntax
+    for (const processorType of args.processorTypes) {
+      promises.push(
+        waitForIndexer({
+          aptosConfig: args.config,
+          minimumLedgerVersion: args.minimumLedgerVersion,
+          processorType,
+        }),
+      );
+    }
+
+    await Promise.all(promises);
+  }
+}

package/src/bcs/deserializer.ts

@@ -222,10 +222,10 @@ export class Deserializer {
    * @example
    * // serialize a vector of addresses
    * const addresses = new Array<AccountAddress>(
-   *   AccountAddress.fromRelaxed("0x1"),
-   *   AccountAddress.fromRelaxed("0x2"),
-   *   AccountAddress.fromRelaxed("0xa"),
-   *   AccountAddress.fromRelaxed("0xb"),
+   *   AccountAddress.from("0x1"),
+   *   AccountAddress.from("0x2"),
+   *   AccountAddress.from("0xa"),
+   *   AccountAddress.from("0xb"),
    * );
    * const serializer = new Serializer();
    * serializer.serializeVector(addresses);

package/src/bcs/serializer.ts

@@ -298,10 +298,10 @@ export class Serializer {
    * @param values The array of BCS Serializable values
    * @example
    * const addresses = new Array<AccountAddress>(
-   *   AccountAddress.fromRelaxed("0x1"),
-   *   AccountAddress.fromRelaxed("0x2"),
-   *   AccountAddress.fromRelaxed("0xa"),
-   *   AccountAddress.fromRelaxed("0xb"),
+   *   AccountAddress.from("0x1"),
+   *   AccountAddress.from("0x2"),
+   *   AccountAddress.from("0xa"),
+   *   AccountAddress.from("0xb"),
    * );
    * const serializer = new Serializer();
    * serializer.serializeVector(addresses);

package/src/client/core.ts

@@ -38,6 +38,9 @@ export async function request<Req, Res>(options: ClientRequest<Req>, client: Cli
   if (overrides?.AUTH_TOKEN && url.includes("faucet")) {
     headers.Authorization = `Bearer ${overrides?.AUTH_TOKEN}`;
   }
+  if (overrides?.API_KEY && !url.includes("faucet")) {
+    headers.Authorization = `Bearer ${overrides?.API_KEY}`;
+  }
 
   /*
    * make a call using the @aptos-labs/aptos-client package
@@ -99,15 +102,14 @@ export async function aptosRequest<Req extends {}, Res extends {}>(
 
   let errorMessage: string;
 
-  // If it is the shape of an AptosApiError, convert it properly
-  if ("message" in response.data && "error_code" in response.data) {
-    errorMessage = JSON.stringify(response.data);
+  if (result && result.data && "message" in result.data && "error_code" in result.data) {
+    errorMessage = JSON.stringify(result.data);
   } else if (result.status in errors) {
     // If it's not an API type, it must come form infra, these are prehandled
     errorMessage = errors[result.status];
   } else {
     // Everything else is unhandled
-    errorMessage = `Unhandled Error ${response.status} : ${response.statusText}`;
+    errorMessage = `Unhandled Error ${result.status} : ${result.statusText}`;
   }
 
   throw new AptosApiError(options, result, errorMessage);

package/src/client/get.ts

@@ -78,17 +78,18 @@ export async function getAptosFullNode<Req extends {}, Res extends {}>(
 }
 
 /// This function is a helper for paginating using a function wrapping an API
-export async function paginateWithCursor<Req extends Record<string, any>, Res extends any[]>(
+export async function paginateWithCursor<Req extends Record<string, any>, Res extends Array<{}>>(
   options: GetAptosRequestOptions,
 ): Promise<Res> {
-  const out = [];
+  const out: any[] = [];
   let cursor: string | undefined;
-  const requestParams = options.params as Req & { start?: string; limit?: number };
+  const requestParams = options.params as { start?: string; limit?: number };
   // eslint-disable-next-line no-constant-condition
   while (true) {
     requestParams.start = cursor;
     // eslint-disable-next-line no-await-in-loop
-    const response = await getAptosFullNode<Req, Res>({
+    const response = await get<Req, Res>({
+      type: AptosApiType.FULLNODE,
       aptosConfig: options.aptosConfig,
       originMethod: options.originMethod,
       path: options.path,
@@ -103,11 +104,11 @@ export async function paginateWithCursor<Req extends Record<string, any>, Res ex
     cursor = response.headers["x-aptos-cursor"];
     // Now that we have the cursor (if any), we remove the headers before
     // adding these to the output of this function.
-    delete (response as any).headers;
+    delete response.headers;
     out.push(...response.data);
     if (cursor === null || cursor === undefined) {
       break;
     }
   }
-  return out as any;
+  return out as Res;
 }

package/src/core/accountAddress.ts

@@ -218,7 +218,7 @@ export class AccountAddress extends Serializable implements TransactionArgument
 
   /**
    * NOTE: This function has strict parsing behavior. For relaxed behavior, please use
-   * the `fromStringRelaxed` function.
+   * the `fromString` function.
    *
    * Creates an instance of AccountAddress from a hex string.
    *
@@ -243,20 +243,20 @@ export class AccountAddress extends Serializable implements TransactionArgument
    *
    * @returns An instance of AccountAddress.
    */
-  static fromString(input: string): AccountAddress {
+  static fromStringStrict(input: string): AccountAddress {
     // Assert the string starts with 0x.
     if (!input.startsWith("0x")) {
       throw new ParsingError("Hex string must start with a leading 0x.", AddressInvalidReason.LEADING_ZERO_X_REQUIRED);
     }
 
-    const address = AccountAddress.fromStringRelaxed(input);
+    const address = AccountAddress.fromString(input);
 
     // Check if the address is in LONG form. If it is not, this is only allowed for
     // special addresses, in which case we check it is in proper SHORT form.
     if (input.length !== AccountAddress.LONG_STRING_LENGTH + 2) {
       if (!address.isSpecial()) {
         throw new ParsingError(
-          `The given hex string ${address} is not a special address, it must be represented as 0x + 64 chars.`,
+          `The given hex string ${input} is not a special address, it must be represented as 0x + 64 chars.`,
           AddressInvalidReason.LONG_FORM_REQUIRED_UNLESS_SPECIAL,
         );
       } else if (input.length !== 3) {
@@ -274,8 +274,8 @@ export class AccountAddress extends Serializable implements TransactionArgument
 
   /**
    * NOTE: This function has relaxed parsing behavior. For strict behavior, please use
-   * the `fromString` function. Where possible use `fromString` rather than this
-   * function, `fromStringRelaxed` is only provided for backwards compatibility.
+   * the `fromStringStrict` function. Where possible use `fromStringStrict` rather than this
+   * function, `fromString` is only provided for backwards compatibility.
    *
    * Creates an instance of AccountAddress from a hex string.
    *
@@ -297,7 +297,7 @@ export class AccountAddress extends Serializable implements TransactionArgument
    *
    * @returns An instance of AccountAddress.
    */
-  static fromStringRelaxed(input: string): AccountAddress {
+  static fromString(input: string): AccountAddress {
     let parsedInput = input;
     // Remove leading 0x for parsing.
     if (input.startsWith("0x")) {
@@ -326,11 +326,10 @@ export class AccountAddress extends Serializable implements TransactionArgument
       // the hex string to bytes. Every two characters in a hex string constitutes a
       // single byte. So a 64 length hex string becomes a 32 byte array.
       addressBytes = hexToBytes(parsedInput.padStart(64, "0"));
-    } catch (e) {
-      const error = e as Error;
+    } catch (error: any) {
       // At this point the only way this can fail is if the hex string contains
       // invalid characters.
-      throw new ParsingError(`Hex characters are invalid: ${error.message}`, AddressInvalidReason.INVALID_HEX_CHARS);
+      throw new ParsingError(`Hex characters are invalid: ${error?.message}`, AddressInvalidReason.INVALID_HEX_CHARS);
     }
 
     return new AccountAddress(addressBytes);
@@ -342,14 +341,14 @@ export class AccountAddress extends Serializable implements TransactionArgument
    * This handles, Uint8array, string, and AccountAddress itself
    * @param input
    */
-  static fromRelaxed(input: AccountAddressInput): AccountAddress {
+  static from(input: AccountAddressInput): AccountAddress {
     if (input instanceof AccountAddress) {
       return input;
     }
     if (input instanceof Uint8Array) {
       return new AccountAddress(input);
     }
-    return AccountAddress.fromStringRelaxed(input);
+    return AccountAddress.fromString(input);
   }
 
   /**
@@ -358,14 +357,14 @@ export class AccountAddress extends Serializable implements TransactionArgument
    * This handles, Uint8array, string, and AccountAddress itself
    * @param input
    */
-  static from(input: AccountAddressInput): AccountAddress {
+  static fromStrict(input: AccountAddressInput): AccountAddress {
     if (input instanceof AccountAddress) {
       return input;
     }
     if (input instanceof Uint8Array) {
       return new AccountAddress(input);
     }
-    return AccountAddress.fromString(input);
+    return AccountAddress.fromStringStrict(input);
   }
 
   // ===
@@ -376,25 +375,24 @@ export class AccountAddress extends Serializable implements TransactionArgument
    * Check if the string is a valid AccountAddress.
    *
    * @param args.input A hex string representing an account address.
-   * @param args.relaxed If true, use relaxed parsing behavior. If false, use strict parsing behavior.
+   * @param args.strict If true, use strict parsing behavior. If false, use relaxed parsing behavior.
    *
    * @returns valid = true if the string is valid, valid = false if not. If the string
    * is not valid, invalidReason will be set explaining why it is invalid.
    */
-  static isValid(args: { input: AccountAddressInput; relaxed?: boolean }): ParsingResult<AddressInvalidReason> {
+  static isValid(args: { input: AccountAddressInput; strict?: boolean }): ParsingResult<AddressInvalidReason> {
     try {
-      if (args.relaxed) {
-        AccountAddress.fromRelaxed(args.input);
+      if (args.strict) {
+        AccountAddress.fromStrict(args.input);
       } else {
         AccountAddress.from(args.input);
       }
       return { valid: true };
-    } catch (e) {
-      const error = e as ParsingError<AddressInvalidReason>;
+    } catch (error: any) {
       return {
         valid: false,
-        invalidReason: error.invalidReason,
-        invalidReasonMessage: error.message,
+        invalidReason: error?.invalidReason,
+        invalidReasonMessage: error?.message,
       };
     }
   }

package/src/core/crypto/anyPublicKey.ts

@@ -77,4 +77,16 @@ export class AnyPublicKey extends PublicKey {
         throw new Error(`Unknown variant index for AnyPublicKey: ${index}`);
     }
   }
+
+  static isPublicKey(publicKey: PublicKey): publicKey is AnyPublicKey {
+    return publicKey instanceof AnyPublicKey;
+  }
+
+  isEd25519(): this is Ed25519PublicKey {
+    return this.publicKey instanceof Ed25519PublicKey;
+  }
+
+  isSecp256k1PublicKey(): this is Secp256k1PublicKey {
+    return this.publicKey instanceof Secp256k1PublicKey;
+  }
 }

package/src/core/crypto/ed25519.ts

@@ -88,6 +88,11 @@ export class Ed25519PublicKey extends PublicKey {
     const bytes = deserializer.deserializeBytes();
     return new Ed25519PublicKey(bytes);
   }
+
+  // TODO(greg): Currently, we can't put this on the abstract type, because of a circular dependency
+  static isPublicKey(publicKey: PublicKey): publicKey is Ed25519PublicKey {
+    return publicKey instanceof Ed25519PublicKey;
+  }
 }
 
 /**
@@ -226,6 +231,10 @@ export class Ed25519PrivateKey extends PrivateKey {
     });
     return new Ed25519PrivateKey(privateKey);
   }
+
+  static isPrivateKey(privateKey: PrivateKey): privateKey is Ed25519PrivateKey {
+    return privateKey instanceof Ed25519PrivateKey;
+  }
 }
 
 /**
@@ -284,4 +293,8 @@ export class Ed25519Signature extends Signature {
     const bytes = deserializer.deserializeBytes();
     return new Ed25519Signature(bytes);
   }
+
+  static isSignature(signature: Signature): signature is Ed25519Signature {
+    return signature instanceof Ed25519Signature;
+  }
 }

package/src/core/crypto/index.ts

@@ -7,3 +7,5 @@ export * from "./multiEd25519";
 export * from "./secp256k1";
 export * from "./multiKey";
 export * from "./hdKey";
+export * from "./anyPublicKey";
+export * from "./anySignature";

package/src/core/crypto/secp256k1.ts

@@ -83,6 +83,10 @@ export class Secp256k1PublicKey extends PublicKey {
     const bytes = deserializer.deserializeBytes();
     return new Secp256k1PublicKey(bytes);
   }
+
+  static isPublicKey(publicKey: PublicKey): publicKey is Secp256k1PublicKey {
+    return publicKey instanceof Secp256k1PublicKey;
+  }
 }
 
 /**
@@ -209,6 +213,10 @@ export class Secp256k1PrivateKey extends PrivateKey {
 
     return new Secp256k1PrivateKey(privateKey);
   }
+
+  static isPrivateKey(privateKey: PrivateKey): privateKey is Secp256k1PrivateKey {
+    return privateKey instanceof Secp256k1PrivateKey;
+  }
 }
 
 /**
@@ -272,4 +280,8 @@ export class Secp256k1Signature extends Signature {
     const bytes = deserializer.deserializeBytes();
     return new Secp256k1Signature(bytes);
   }
+
+  static isSignature(signature: Signature): signature is Secp256k1Signature {
+    return signature instanceof Secp256k1Signature;
+  }
 }

package/src/core/hex.ts

@@ -115,10 +115,9 @@ export class Hex {
 
     try {
       return new Hex(hexToBytes(input));
-    } catch (e) {
-      const error = e as Error;
+    } catch (error: any) {
       throw new ParsingError(
-        `Hex string contains invalid hex characters: ${error.message}`,
+        `Hex string contains invalid hex characters: ${error?.message}`,
         HexInvalidReason.INVALID_HEX_CHARS,
       );
     }
@@ -153,12 +152,11 @@ export class Hex {
     try {
       Hex.fromString(str);
       return { valid: true };
-    } catch (e) {
-      const error = e as ParsingError<HexInvalidReason>;
+    } catch (error: any) {
       return {
         valid: false,
-        invalidReason: error.invalidReason,
-        invalidReasonMessage: error.message,
+        invalidReason: error?.invalidReason,
+        invalidReasonMessage: error?.message,
       };
     }
   }

package/src/index.ts

@@ -6,5 +6,6 @@ export * from "./bcs";
 export * from "./client";
 export * from "./core";
 export * from "./transactions";
+export * from "./transactions/management";
 export * from "./types";
 export * from "./utils";