aftermath-ts-sdk

import { BcsType } from "@mysten/sui/bcs"; import { SuiFrensApiCasting } from "../../packages/suiFrens/api/suiFrensApiCasting"; import { FaucetApiCasting } from "../../packages/faucet/api/faucetApiCasting"; import { NftAmmApiCasting } from "../../packages/nftAmm/api/nftAmmApiCasting"; import { PoolsApiCasting } from "../../packages/pools/api/poolsApiCasting"; import { StakingApiCasting } from "../../packages/staking/api/stakingApiCasting"; import { Byte, Percentage, SuiAddress } from "../types"; import { RouterApiCasting } from "../../packages/router/api/routerApiCasting"; import { FixedUtils } from "./fixedUtils"; import { IFixedUtils } from "./iFixedUtils"; import { PerpetualsApiCasting } from "../../packages/perpetuals/api/perpetualsApiCasting"; import { FarmsApiCasting } from "../../packages/farms/api/farmsApiCasting"; import { LeveragedStakingApiCasting } from "../../packages/leveragedStaking/api/leveragedStakingApiCasting"; import { SuiObjectResponse } from "@mysten/sui/client"; import { NftsApiCasting } from "../nfts/nftsApiCasting"; import { OracleApiCasting } from "../../packages/oracle/api/oracleApiCasting"; /** * A central utility class for casting and conversion routines across * different Aftermath modules. Provides both direct numeric transformations * (e.g., fixed-point arithmetic) and advanced BCS-based object deserialization. */ export declare class Casting { /** * Casting utilities for pools-related data (AMM pools, liquidity, etc.). */ static pools: typeof PoolsApiCasting; /** * Casting utilities for SuiFrens-related data or objects. */ static suiFrens: typeof SuiFrensApiCasting; /** * Casting utilities for faucet-related data, typically for devnet or testnet tokens. */ static faucet: typeof FaucetApiCasting; /** * Casting utilities for staking-related data (positions, pools, etc.). */ static staking: typeof StakingApiCasting; /** * Casting utilities for leveraged staking data structures. */ static leveragedStaking: typeof LeveragedStakingApiCasting; /** * Casting utilities for NFT AMM objects and events. */ static nftAmm: typeof NftAmmApiCasting; /** * Casting utilities for router-based data, such as trade routes and DEX interactions. */ static router: typeof RouterApiCasting; /** * Casting utilities for perpetuals/futures data. */ static perpetuals: typeof PerpetualsApiCasting; /** * Casting utilities for oracle-based data or price feed objects. */ static oracle: typeof OracleApiCasting; /** * Casting utilities for farming data (yield farms, locked positions, etc.). */ static farms: typeof FarmsApiCasting; /** * Casting utilities for NFT structures and data retrieval logic. */ static nfts: typeof NftsApiCasting; /** * Reference to the standard fixed-point arithmetic utilities (18 decimals). */ static Fixed: typeof FixedUtils; /** * Reference to the intermediate fixed type (signed 18 decimals). */ static IFixed: typeof IFixedUtils; /** * The maximum unsigned 64-bit integer value as a bigint (0xFFFFFFFFFFFFFFFF). */ static u64MaxBigInt: bigint; /** * Converts a floating-point number to a fixed bigint with 18 decimals. * For example, `1.23` => `1230000000000000000n` if we consider 18 decimals. * * @param a - The number to convert. * @returns A bigint representing the number in 18-decimal fixed format. */ static numberToFixedBigInt: (a: number) => bigint; /** * Converts an 18-decimal fixed bigint to a floating-point number. * For example, `1230000000000000000n` => `1.23`. * * @param a - The fixed bigint to convert. * @returns A floating-point representation of the 18-decimal fixed value. */ static bigIntToFixedNumber: (a: bigint) => number; /** * Scales a bigint by a floating-point scalar. For instance, a scalar of 0.5 * and a bigint of 100 => 50n. * * @param scalar - The floating-point multiplier (e.g., 0.5). * @param int - The bigint to be scaled. * @returns A bigint result after scaling. */ static scaleNumberByBigInt: (scalar: number, int: bigint) => bigint; /** * Converts a decimal percentage into basis points (bps), returned as a bigint. * For example, 0.05 => 500 bps. * * @param percentage - The decimal percentage to convert (e.g., 0.05 for 5%). * @returns A bigint representing basis points. */ static percentageToBps(percentage: Percentage): bigint; /** * Converts a bigint basis points value back to a decimal percentage. * For example, 500n => 0.05 (5%). * * @param bps - The bigint basis points to convert (e.g., 500n). * @returns The decimal percentage (0.05). */ static bpsToPercentage(bps: bigint): Percentage; /** * Converts an array of bytes into a string by interpreting each byte as a character code. * * @param bytes - An array of bytes to convert. * @returns The resulting ASCII string. */ static stringFromBytes: (bytes: Byte[]) => string; /** * Interprets an array of bytes as a little-endian hex string, converting * that string into a bigint. For example, `[0x01, 0x02]` => `0x0201` => `513n`. * * @param bytes - An array of bytes. * @returns The resulting bigint from the hex. */ static bigIntFromBytes: (bytes: Byte[]) => bigint; /** * Converts BCS-encoded address bytes into a SuiAddress (0x...) string, * preserving any needed leading zeroes. * * @param bytes - The address bytes in BCS-encoded form. * @returns A normalized Sui address string (e.g., "0x000123..."). */ static addressFromBcsBytes: (bytes: Byte[]) => SuiAddress; /** * Converts an array of bytes directly to a Sui address string in "0x..." format, * adding any leading zeros if needed. * * @param bytes - The raw bytes for the address. * @returns A normalized Sui address. */ static addressFromBytes: (bytes: Byte[]) => SuiAddress; /** * Converts an array of hex string bytes into a Sui address. Each element of * the array is a string representing a byte (e.g., `["255", "0", ...]`). * * @param bytes - An array of stringified bytes to convert. * @returns A normalized Sui address. */ static addressFromStringBytes: (bytes: string[]) => SuiAddress; /** * Converts an array of decimal-encoded string bytes (e.g., `["255", "0"]`) * into a numeric `Byte[]` array. * * @param bytes - The string array representing decimal values. * @returns A numeric array of bytes. */ static bytesFromStringBytes: (bytes: string[]) => Byte[]; /** * Unwraps a deserialized "Option" type from the BCS, returning its contents * if present, or `undefined` if not. * * @param deserializedData - The BCS-deserialized structure that might contain `{ Some: value }` or `{ None: true }`. * @returns The unwrapped data if present, or `undefined`. */ static unwrapDeserializedOption: (deserializedData: any) => any | undefined; /** * Encodes a JavaScript string into a UTF-8 `Uint8Array`, suitable for * on-chain usage or hashing. * * @param str - The string to encode. * @returns An array of numeric bytes representing the UTF-8 encoded string. */ static u8VectorFromString: (str: string) => number[]; /** * Normalizes a user-provided slippage tolerance from an integer percentage * into a decimal fraction. E.g., `1 => 0.01`. * * @param slippageTolerance - The slippage in integer percent form (e.g., 1 for 1%). * @returns A decimal fraction (e.g., 0.01). */ static normalizeSlippageTolerance: (slippageTolerance: number) => number; /** * Deserializes a `SuiObjectResponse`'s BCS bytes into an object of type `T` using * a specified `bcsType`. Typically used for on-chain object decoding. * * @param inputs - The inputs including `suiObjectResponse`, `bcsType`, and a `fromDeserialized` transform function. * @returns The transformed object of type `T` after BCS deserialization. * @throws If no BCS bytes are found in the object. */ static castObjectBcs: <T, U>(inputs: { suiObjectResponse: SuiObjectResponse; bcsType: BcsType<U>; fromDeserialized: (deserialized: U) => T; }) => T; /** * Extracts base64 BCS bytes from a `SuiObjectResponse` if present. Throws an error otherwise. * * @param suiObjectResponse - The Sui object response containing `bcsBytes`. * @returns A base64 string representing the object's BCS data. * @throws If the object response does not contain `bcsBytes`. */ static bcsBytesFromSuiObjectResponse(suiObjectResponse: SuiObjectResponse): string; } //# sourceMappingURL=casting.d.ts.map