aftermath-ts-sdk 1.2.63 → 1.2.64-docs.0

package/dist/general/utils/fixedUtils.js

@@ -1,23 +1,100 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FixedUtils = void 0;
+/**
+ * The `FixedUtils` class provides utilities for fixed-point arithmetic
+ * with a standard 18-decimal precision, along with some convenience
+ * methods for normalizing/un-normalizing amounts based on token decimals.
+ */
 class FixedUtils {
 }
 exports.FixedUtils = FixedUtils;
-// 18 decimal places
+/**
+ * Represents 1.0 in 18-decimal fixed math as a float: 1_000_000_000_000_000_000.
+ */
 FixedUtils.fixedOneN = 1000000000000000000;
+/**
+ * Represents 1.0 in 18-decimal fixed math as a bigint: 1000000000000000000n.
+ */
 FixedUtils.fixedOneB = BigInt("1000000000000000000");
-// 9 decimal places
+/**
+ * Represents 1.0 in 9-decimal fixed math as a float: 1_000_000_000.
+ */
 FixedUtils.fixedOneN9 = 1000000000;
+/**
+ * Represents 1.0 in 9-decimal fixed math as a bigint: 1000000000n.
+ */
 FixedUtils.fixedOneB9 = BigInt(1000000000);
-// These terms come from their on chain counterparts. They are backwards from the point of view of js.
-// On chain direct cast means e.g. taking ((x: u64) as u256).
+// These methods relate to direct cast/un-cast logic for on-chain usage:
+/**
+ * Directly convert an on-chain `u64` (stored as a bigint) into a float, effectively no scaling.
+ *
+ * @param n - The on-chain number as a bigint.
+ * @returns The converted number as a float.
+ */
 FixedUtils.convertFromInt = (n) => Number(n);
+/**
+ * Convert a floating number back to an on-chain integer (bigint),
+ * truncating decimals.
+ *
+ * @param n - The local float.
+ * @returns The truncated bigint.
+ */
 FixedUtils.convertToInt = (n) => BigInt(Math.floor(n));
+/**
+ * Converts a fixed-18 on-chain number to a floating local number by dividing by `fixedOneN`.
+ *
+ * @param n - The on-chain 18-decimal fixed number (as a bigint).
+ * @returns A float representing the unscaled value.
+ */
 FixedUtils.directCast = (n) => Number(n) / FixedUtils.fixedOneN;
+/**
+ * Converts a floating local number to an on-chain 18-decimal fixed bigint by multiplying by `fixedOneN`.
+ *
+ * @param n - The local float to be scaled.
+ * @returns The scaled 18-decimal fixed as a bigint.
+ */
 FixedUtils.directUncast = (n) => BigInt(Math.floor(n * FixedUtils.fixedOneN));
+/**
+ * Returns the complement of the number in `[0,1]`, i.e., `1 - n`.
+ * If `n` is negative, it's treated as zero; if `n` > 1, also treated as zero for the complement.
+ *
+ * @param n - The local float in [0,1].
+ * @returns The complement of `n` in [0,1].
+ */
 FixedUtils.complement = (n) => Math.max(0, 1 - Math.max(0, n));
+/**
+ * Multiplies a raw integer `amount` by a `decimalsScalar` to produce
+ * a "normalized" form. E.g., if decimals = 9, we store it as 10^9 scale.
+ *
+ * @param decimalsScalar - The scale factor for the coin (e.g., 1e9).
+ * @param amount - The raw integer (balance) to be scaled.
+ * @returns The scaled (normalized) amount as a `number`.
+ */
 FixedUtils.normalizeAmount = (decimalsScalar, amount) => amount * decimalsScalar;
+/**
+ * Divides a normalized amount by the `decimalsScalar` to get back the
+ * raw on-chain integer. This is typically used after floating computations.
+ *
+ * @param decimalsScalar - The scale factor for the coin (e.g., 1e9).
+ * @param normalizedAmount - The scaled amount to reduce.
+ * @returns The raw integer balance.
+ */
 FixedUtils.unnormalizeAmount = (decimalsScalar, normalizedAmount) => normalizedAmount / decimalsScalar;
+/**
+ * Directly cast a `Balance` to an 18-decimal float, factoring in token decimals.
+ *
+ * @param decimalsScalar - The token's decimal scale factor.
+ * @param amount - The raw integer `Balance`.
+ * @returns A float representing the 18-decimal scale cast.
+ */
 FixedUtils.castAndNormalize = (decimalsScalar, amount) => FixedUtils.directCast(FixedUtils.normalizeAmount(decimalsScalar, amount));
+/**
+ * Reverse the cast of a normalized float back to a raw `Balance`,
+ * factoring in the token decimals.
+ *
+ * @param decimalsScalar - The token's decimal scale factor.
+ * @param normalizedAmount - A local float in 18-decimal domain.
+ * @returns A raw integer `Balance`.
+ */
 FixedUtils.uncastAndUnnormalize = (decimalsScalar, normalizedAmount) => FixedUtils.unnormalizeAmount(decimalsScalar, FixedUtils.directUncast(normalizedAmount));

package/dist/general/utils/helpers.d.ts

@@ -9,72 +9,366 @@ import { Transaction, TransactionObjectArgument } from "@mysten/sui/transactions
 import { MoveErrors } from "../types/moveErrorsInterface";
 import { Keypair } from "@mysten/sui/cryptography";
 /**
- * A utility class containing various helper functions for general use.
+ * A utility class containing various helper functions for general use across
+ * the Aftermath TS ecosystem. This includes numeric operations, object field
+ * extraction, array transformations, slippage adjustments, and Move error parsing.
  */
 export declare class Helpers {
+    /**
+     * Static reference to the `DynamicFieldsApiHelpers`, providing utility methods
+     * for working with dynamic fields in Sui objects.
+     */
     static readonly dynamicFields: typeof DynamicFieldsApiHelpers;
+    /**
+     * Static reference to the `EventsApiHelpers`, providing methods for
+     * querying and filtering Sui events.
+     */
     static readonly events: typeof EventsApiHelpers;
+    /**
+     * Static reference to the `InspectionsApiHelpers`, used for reading
+     * Summaries or inspection data from objects.
+     */
     static readonly inspections: typeof InspectionsApiHelpers;
+    /**
+     * Static reference to the `ObjectsApiHelpers`, providing direct
+     * retrieval or manipulation of on-chain Sui objects.
+     */
     static readonly objects: typeof ObjectsApiHelpers;
+    /**
+     * Static reference to the `TransactionsApiHelpers`, enabling easier
+     * queries for transaction data by digest or other criteria.
+     */
     static readonly transactions: typeof TransactionsApiHelpers;
     /**
-     * Removes leading zeroes from the hexadecimal representation of a given object type.
-     * @param type - The object type to strip leading zeroes from.
-     * @returns The object type with leading zeroes removed from its hexadecimal representation.
+     * Removes all leading zeroes (after the '0x') from a string that represents
+     * a Sui address or object type. For instance, "0x0000123" => "0x123".
+     *
+     * @param type - The hex string to process, potentially including "::" module syntax.
+     * @returns The same string with unnecessary leading zeroes stripped out.
      */
     static stripLeadingZeroesFromType: (type: AnyObjectType) => AnyObjectType;
     /**
-     * Adds leading zeroes to a given `AnyObjectType` until it reaches a length of 64 characters.
-     * If the input type already has a length greater than 64, an error is thrown.
-     * @param type - The `AnyObjectType` to add leading zeroes to.
-     * @returns The modified `AnyObjectType` with leading zeroes added.
-     * @throws An error if the input type has a length greater than 64.
+     * Ensures the given Sui address or object type is zero-padded to 64 hex digits
+     * after the "0x". If a "::" suffix is present, only the address portion is padded.
+     *
+     * @param type - The "0x..." string or extended type (0x..::module).
+     * @returns A new string normalized to a 64-hex-digit address or object ID.
+     * @throws If the address portion is already longer than 64 hex digits.
      */
     static addLeadingZeroesToType: (type: AnyObjectType) => AnyObjectType;
+    /**
+     * Splits a non-SUI coin type string that may be prefixed by a chain ID for external usage,
+     * returning the chain and the coin type. If no chain is recognized, defaults to `"sui"`.
+     *
+     * @param coin - The coin string, which may look like `"bsc:0x<...>"` or just `"0x<...>"`.
+     * @returns An object with the `chain` (e.g. "bsc") and the `coinType`.
+     */
     static splitNonSuiCoinType: (coin: CoinType) => {
         chain: CoinGeckoChain;
         coinType: CoinType;
     };
+    /**
+     * Checks if a given string represents a valid number (integer or decimal).
+     *
+     * @param str - The string to test.
+     * @returns `true` if it's a valid numeric string, otherwise `false`.
+     */
     static isNumber: (str: string) => boolean;
+    /**
+     * Sums an array of floating-point numbers, returning the numeric total.
+     *
+     * @param arr - The array of numbers to sum.
+     * @returns The total as a float.
+     */
     static sum: (arr: number[]) => number;
+    /**
+     * Sums an array of bigints, returning the total as a bigint.
+     *
+     * @param arr - The array of bigints to sum.
+     * @returns The resulting total as a bigint.
+     */
     static sumBigInt: (arr: bigint[]) => bigint;
+    /**
+     * Determines if two numbers are close within a given tolerance factor,
+     * i.e., `|a - b| <= tolerance * max(a, b)`.
+     *
+     * @param a - The first number.
+     * @param b - The second number.
+     * @param tolerance - A fraction representing the max allowed difference relative to max(a, b).
+     * @returns `true` if within tolerance, otherwise `false`.
+     */
     static closeEnough: (a: number, b: number, tolerance: number) => boolean;
+    /**
+     * Determines if two bigints are close within a given tolerance factor,
+     * by casting them to numbers internally.
+     *
+     * @param a - First bigint.
+     * @param b - Second bigint.
+     * @param tolerance - A fraction representing the max allowed difference relative to max(a, b).
+     * @returns `true` if within tolerance, otherwise `false`.
+     */
     static closeEnoughBigInt: (a: bigint, b: bigint, tolerance: number) => boolean;
+    /**
+     * Checks whether the integer divisions of `a` and `b` (by `fixedOne`) differ
+     * by at most 1. Typically used in fixed math scenarios to see if two scaled
+     * values are "very close."
+     *
+     * @param a - First number (scaled).
+     * @param b - Second number (scaled).
+     * @param fixedOne - The scaling factor representing 1.0 in the same scale as `a` and `b`.
+     * @returns `true` if the integer parts differ by <= 1, otherwise `false`.
+     */
     static veryCloseInt: (a: number, b: number, fixedOne: number) => boolean;
+    /**
+     * A small object containing "blended" math operations that handle
+     * mixed numeric types (number vs. bigint). This is primarily for
+     * internal usage in advanced math scenarios.
+     */
     static blendedOperations: {
+        /**
+         * Multiply two floating-point numbers.
+         */
         mulNNN: (a: number, b: number) => number;
+        /**
+         * Multiply a float and a bigint, returning a bigint (floor).
+         */
         mulNNB: (a: number, b: number) => bigint;
+        /**
+         * Multiply a float and a bigint, returning a float.
+         */
         mulNBN: (a: number, b: bigint) => number;
+        /**
+         * Multiply a float and a bigint, returning a bigint (floor).
+         */
         mulNBB: (a: number, b: bigint) => bigint;
+        /**
+         * Multiply two bigints, returning a float.
+         */
         mulBBN: (a: bigint, b: bigint) => number;
+        /**
+         * Multiply two bigints, returning a bigint.
+         */
         mulBBB: (a: bigint, b: bigint) => bigint;
     };
+    /**
+     * Returns the maximum of multiple bigints.
+     *
+     * @param args - The bigints to compare.
+     * @returns The largest bigint.
+     */
     static maxBigInt: (...args: bigint[]) => bigint;
+    /**
+     * Returns the minimum of multiple bigints.
+     *
+     * @param args - The bigints to compare.
+     * @returns The smallest bigint.
+     */
     static minBigInt: (...args: bigint[]) => bigint;
+    /**
+     * Returns the absolute value of a bigint.
+     *
+     * @param num - The input bigint.
+     * @returns A bigint representing the absolute value of `num`.
+     */
     static absBigInt: (num: bigint) => bigint;
+    /**
+     * Capitalizes only the first letter of a string, making the rest lowercase.
+     * E.g., "HELLO" => "Hello".
+     *
+     * @param str - The input string to transform.
+     * @returns The resulting string with the first character in uppercase and the rest in lowercase.
+     */
     static capitalizeOnlyFirstLetter: (str: string) => string;
+    /**
+     * Parses a JSON string containing potential BigInt values.
+     * By default, it only converts strings ending in 'n' (like `"123n"`) to BigInts.
+     *
+     * @param json - The JSON string to parse.
+     * @param unsafeStringNumberConversion - If `true`, all numeric strings (e.g., "123") will also become BigInts.
+     * @returns The parsed JSON object with BigInt conversions where applicable.
+     */
     static parseJsonWithBigint: (json: string, unsafeStringNumberConversion?: boolean) => any;
+    /**
+     * Creates a deep copy of the given target, handling nested arrays and objects.
+     * Dates are cloned by their timestamp.
+     *
+     * @param target - The data to clone deeply.
+     * @returns A new object/array/date structure mirroring `target`.
+     */
     static deepCopy: <T>(target: T) => T;
+    /**
+     * Finds the index of the maximum value in an array. Returns -1 if the array is empty.
+     *
+     * @param arr - The input array.
+     * @returns The index of the maximum value, or -1 if the array is empty.
+     */
     static indexOfMax: (arr: any[]) => number;
+    /**
+     * Returns a new array with unique elements from the input array,
+     * preserving the order of first occurrences.
+     *
+     * @param arr - The original array.
+     * @returns An array of unique items.
+     */
     static uniqueArray: <T>(arr: T[]) => T[];
+    /**
+     * Returns a Promise that resolves after a specified number of milliseconds.
+     *
+     * @param ms - The delay time in milliseconds.
+     * @returns A promise that resolves after `ms` milliseconds.
+     */
     static sleep: (ms: number) => Promise<unknown>;
+    /**
+     * Creates a unique ID-like string by combining the current timestamp and random base36 digits.
+     *
+     * @returns A short random string (base36) that can serve as a unique identifier.
+     */
     static createUid: () => string;
+    /**
+     * Splits an array into two groups: those for which `func` returns `true` (or truthy),
+     * and those for which it returns `false`. The result is returned as a tuple `[trues, falses]`.
+     *
+     * @param array - The array to filter.
+     * @param func - The function used to test each element.
+     * @returns A tuple containing two arrays: `[elements that pass, elements that fail]`.
+     */
     static bifilter: <ArrayType>(array: ArrayType[], func: (item: ArrayType, index: number, arr: ArrayType[]) => boolean) => [trues: ArrayType[], falses: ArrayType[]];
+    /**
+     * An async version of `bifilter`, returning a tuple of `[trues, falses]`.
+     * Each element is tested asynchronously in parallel via `func`.
+     *
+     * @param array - The array to filter.
+     * @param func - An async function returning `true` or `false`.
+     * @returns A tuple `[trues, falses]` after asynchronous evaluation.
+     */
     static bifilterAsync: <ArrayType>(array: ArrayType[], func: (item: ArrayType, index: number, arr: ArrayType[]) => Promise<boolean>) => Promise<[trues: ArrayType[], falses: ArrayType[]]>;
+    /**
+     * Filters the entries of an object based on a predicate function,
+     * returning a new object with only those entries for which `predicate`
+     * returns `true`.
+     *
+     * @param obj - The original object to filter.
+     * @param predicate - A function taking `(key, value)` and returning a boolean.
+     * @returns A new object with only the entries that pass the predicate.
+     */
     static filterObject: <Value>(obj: Record<string, Value>, predicate: (key: string, value: Value) => boolean) => Record<string, Value>;
+    /**
+     * Applies downward slippage to a bigint amount by subtracting `slippage * amount`.
+     * For instance, for 1% slippage, we reduce the amount by 1%.
+     *
+     * @param amount - The original bigint amount.
+     * @param slippage - An integer percent (e.g., 1 => 1%).
+     * @returns The adjusted bigint after subtracting the slippage portion.
+     */
     static applySlippageBigInt: (amount: Balance, slippage: Slippage) => bigint;
+    /**
+     * Applies downward slippage to a floating-point amount. E.g., for 1% slippage,
+     * reduce by 1% of `amount`.
+     *
+     * @param amount - The original float value.
+     * @param slippage - An integer percent (e.g., 1 => 1%).
+     * @returns The float after applying slippage.
+     */
     static applySlippage: (amount: number, slippage: Slippage) => number;
+    /**
+     * Combines two arrays into a single array of pairs. The result length is the
+     * minimum of the two input arrays' lengths.
+     *
+     * @param firstCollection - The first array.
+     * @param lastCollection - The second array.
+     * @returns An array of `[firstCollection[i], lastCollection[i]]` pairs.
+     */
     static zip<S1, S2>(firstCollection: Array<S1>, lastCollection: Array<S2>): Array<[S1, S2]>;
+    /**
+     * Removes circular references from an object or array, returning a JSON-safe structure.
+     * Any cyclic references are replaced with `undefined`.
+     *
+     * @param obj - The object or array to remove circular references from.
+     * @param seen - Internal usage to track references that have already been visited.
+     * @returns A structure that can be safely JSON-stringified.
+     */
     static removeCircularReferences<T>(obj: T, seen?: WeakSet<object>): T | undefined;
+    /**
+     * Checks if an unknown value is an array of strings.
+     *
+     * @param value - The value to check.
+     * @returns `true` if `value` is a string array, otherwise `false`.
+     */
     static isArrayOfStrings(value: unknown): value is string[];
+    /**
+     * Roughly checks if a string is a valid Sui type (e.g., "0x2::sui::SUI").
+     * This is not guaranteed to be perfect, but covers common cases.
+     *
+     * @param str - The string to validate.
+     * @returns `true` if it meets the minimum structure, otherwise `false`.
+     */
     static isValidType: (str: string) => boolean;
+    /**
+     * Checks if a string is a valid hex representation, optionally prefixed with "0x".
+     *
+     * @param hexString - The string to check.
+     * @returns `true` if `hexString` is a valid hex, otherwise `false`.
+     */
     static isValidHex: (hexString: string) => boolean;
+    /**
+     * Extracts the fully qualified type (e.g., "0x2::coin::Coin<...>") from a `SuiObjectResponse`,
+     * normalizing it with leading zeroes if necessary.
+     *
+     * @param data - The object response from Sui.
+     * @returns The normalized object type string.
+     * @throws If the type is not found.
+     */
     static getObjectType(data: SuiObjectResponse): ObjectId;
+    /**
+     * Extracts the object ID from a `SuiObjectResponse`, normalizing it with leading zeroes.
+     *
+     * @param data - The object response from Sui.
+     * @returns A zero-padded `ObjectId`.
+     * @throws If the objectId is not found.
+     */
     static getObjectId(data: SuiObjectResponse): ObjectId;
+    /**
+     * Retrieves the fields of a Move object from a `SuiObjectResponse`.
+     *
+     * @param data - The Sui object response containing a Move object.
+     * @returns A record of fields for that object.
+     * @throws If no fields are found.
+     */
     static getObjectFields(data: SuiObjectResponse): Record<string, any>;
+    /**
+     * Retrieves display metadata from a Sui object response, if present.
+     *
+     * @param data - The Sui object response.
+     * @returns The display fields for that object.
+     * @throws If display fields are not found.
+     */
     static getObjectDisplay(data: SuiObjectResponse): DisplayFieldsResponse;
+    /**
+     * Utility for building transaction commands with either a string-based
+     * `ObjectId` or an existing transaction object argument. If it's a string,
+     * it's converted via `tx.object(...)`; if already a `TransactionObjectArgument`,
+     * it's returned as-is.
+     *
+     * @param tx - The current `Transaction` block to add the object to.
+     * @param object - Either an `ObjectId` or a `TransactionObjectArgument`.
+     * @returns A `TransactionObjectArgument` referencing the provided object.
+     */
     static addTxObject: (tx: Transaction, object: ObjectId | TransactionObjectArgument) => TransactionObjectArgument;
+    /**
+     * Checks if a given string is a valid Sui address by normalizing it to a
+     * 64-hex-digit form and calling `isValidSuiAddress`.
+     *
+     * @param address - The Sui address to validate.
+     * @returns `true` if valid, `false` otherwise.
+     */
     static isValidSuiAddress: (address: SuiAddress) => boolean;
+    /**
+     * Parses a MoveAbort error message from Sui into a possible `(errorCode, packageId, module)`,
+     * if the message follows a known pattern. Otherwise returns undefined.
+     *
+     * @param inputs - The object containing the raw `errorMessage` from Sui.
+     * @returns A partial structure of the error details or undefined.
+     */
     static parseMoveErrorMessage(inputs: {
         errorMessage: string;
     }): {
@@ -82,6 +376,14 @@ export declare class Helpers {
         packageId: ObjectId;
         module: ModuleName;
     } | undefined;
+    /**
+     * Translates a Move abort error message into a known error string if it matches
+     * entries in a given `moveErrors` table. This is used to map on-chain error codes
+     * to user-friendly messages.
+     *
+     * @param inputs - Includes the raw `errorMessage` and a `moveErrors` object keyed by package, module, and code.
+     * @returns A structure with `errorCode`, `packageId`, `module`, and a human-readable `error` string, or `undefined`.
+     */
     static translateMoveErrorMessage(inputs: {
         errorMessage: string;
         moveErrors: MoveErrors;
@@ -91,6 +393,15 @@ export declare class Helpers {
         module: ModuleName;
         error: string;
     } | undefined;
+    /**
+     * Constructs a `Keypair` instance from a private key string. The `privateKey`
+     * may indicate the signing scheme (ED25519, Secp256k1, or Secp256r1) via prefix,
+     * as recognized by `decodeSuiPrivateKey`.
+     *
+     * @param privateKey - The full private key string (e.g., "0x<64_hex_chars>").
+     * @returns A new `Keypair` instance for signing transactions.
+     * @throws If the schema is unsupported.
+     */
     static keypairFromPrivateKey: (privateKey: string) => Keypair;
 }
 //# sourceMappingURL=helpers.d.ts.map

package/dist/general/utils/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/general/utils/helpers.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/general/utils/helpers.ts"],"names":[],"mappings":"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"}