aftermath-ts-sdk 1.3.28 → 2.0.0

package/dist/packages/pools/pool.js

@@ -1,647 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Pool = void 0;
-const cmmmCalculations_1 = require("./utils/cmmmCalculations");
-const caller_1 = require("../../general/utils/caller");
-const _1 = require(".");
-const utils_1 = require("../../general/utils");
-/**
- * The `Pool` class encapsulates all the functionality needed to interact
- * with a specific AMM pool on the Aftermath platform. It allows you to
- * calculate trade amounts, deposit/withdraw amounts, fetch transactions,
- * and retrieve on-chain statistics and event data.
- *
- * @example
- * ```typescript
- * const afSdk = new Aftermath("MAINNET");
- * await afSdk.init(); // initialize provider
- *
- * const pools = afSdk.Pools();
- * const pool = await pools.getPool({ objectId: "0x..." });
- *
- * const stats = await pool.getStats();
- * const tradeTx = await pool.getTradeTransaction({
- *   walletAddress: "0x...",
- *   coinInType: "0x2::sui::SUI",
- *   coinInAmount: BigInt(1e9),
- *   coinOutType: "0x<yourCoin>",
- *   slippage: 0.01,
- * });
- * ```
- */
-class Pool extends caller_1.Caller {
-    /**
-     * Creates a new instance of the `Pool` class for on-chain interaction.
-     *
-     * @param pool - The fetched `PoolObject` from Aftermath API or on-chain query.
-     * @param config - Optional caller configuration (e.g., network, access token).
-     * @param Provider - An optional `AftermathApi` instance for advanced transaction usage.
-     */
-    constructor(pool, config, Provider) {
-        super(config, `pools/${pool.objectId}`);
-        this.pool = pool;
-        this.Provider = Provider;
-        /**
-         * Retrieves the 24-hour volume for this specific pool.
-         *
-         * @returns A promise resolving to a number (volume in 24h).
-         *
-         * @example
-         * ```typescript
-         * const vol24h = await pool.getVolume24hrs();
-         * console.log("Pool 24h Volume:", vol24h);
-         * ```
-         */
-        this.getVolume24hrs = () => __awaiter(this, void 0, void 0, function* () {
-            return this.fetchApi("volume-24hrs");
-        });
-        // =========================================================================
-        //  Calculations
-        // =========================================================================
-        /**
-         * Calculates the instantaneous spot price for swapping from `coinInType`
-         * to `coinOutType` within this pool. Optionally includes fees in the price.
-         *
-         * @param inputs - Object specifying input coin, output coin, and a boolean for `withFees`.
-         * @returns The numerical spot price (float).
-         *
-         * @example
-         * ```typescript
-         * const price = pool.getSpotPrice({
-         *   coinInType: "0x<coinA>",
-         *   coinOutType: "0x<coinB>",
-         *   withFees: true,
-         * });
-         * console.log("Spot Price:", price);
-         * ```
-         */
-        this.getSpotPrice = (inputs) => {
-            const spotPriceWithDecimals = cmmmCalculations_1.CmmmCalculations.calcSpotPriceWithFees(utils_1.Helpers.deepCopy(this.pool), inputs.coinInType, inputs.coinOutType, !inputs.withFees);
-            // Adjust for decimals difference
-            return ((spotPriceWithDecimals *
-                Number(this.pool.coins[inputs.coinOutType].decimalsScalar)) /
-                Number(this.pool.coins[inputs.coinInType].decimalsScalar));
-        };
-        // TODO: account for referral discount for all calculations
-        /**
-         * Calculates how much output coin you would receive when trading
-         * a given input coin and amount in this pool, factoring in protocol
-         * and optional DAO fees.
-         *
-         * @param inputs - Includes `coinInType`, `coinInAmount`, and `coinOutType`.
-         * @returns A bigint representing how many output coins you'd get.
-         * @throws Error if the trade amount is too large relative to the pool balance.
-         *
-         * @example
-         * ```typescript
-         * const amountOut = pool.getTradeAmountOut({
-         *   coinInType: "0x<coinA>",
-         *   coinInAmount: BigInt(1000000),
-         *   coinOutType: "0x<coinB>",
-         * });
-         * ```
-         */
-        this.getTradeAmountOut = (inputs) => {
-            const pool = utils_1.Helpers.deepCopy(this.pool);
-            const coinInPoolBalance = pool.coins[inputs.coinInType].balance;
-            const coinOutPoolBalance = pool.coins[inputs.coinOutType].balance;
-            const coinInAmountWithFees = this.getAmountWithDAOFee({
-                amount: _1.Pools.getAmountWithProtocolFees({
-                    amount: inputs.coinInAmount,
-                }),
-            });
-            if (Number(coinInAmountWithFees) / Number(coinInPoolBalance) >=
-                _1.Pools.constants.bounds.maxTradePercentageOfPoolBalance -
-                    Pool.constants.percentageBoundsMarginOfError)
-                throw new Error("coinInAmountWithFees / coinInPoolBalance >= maxTradePercentageOfPoolBalance");
-            const coinOutAmount = cmmmCalculations_1.CmmmCalculations.calcOutGivenIn(pool, inputs.coinInType, inputs.coinOutType, coinInAmountWithFees);
-            if (coinOutAmount <= 0)
-                throw new Error("coinOutAmount <= 0");
-            if (Number(coinOutAmount) / Number(coinOutPoolBalance) >=
-                _1.Pools.constants.bounds.maxTradePercentageOfPoolBalance -
-                    Pool.constants.percentageBoundsMarginOfError)
-                throw new Error("coinOutAmount / coinOutPoolBalance >= maxTradePercentageOfPoolBalance");
-            return coinOutAmount;
-        };
-        /**
-         * Calculates how much input coin is required to obtain a certain output coin amount
-         * from this pool, factoring in fees.
-         *
-         * @param inputs - Includes `coinInType`, desired `coinOutAmount`, and `coinOutType`.
-         * @returns A bigint representing the needed input amount.
-         * @throws Error if the desired output is too large relative to pool balances.
-         *
-         * @example
-         * ```typescript
-         * const amountIn = pool.getTradeAmountIn({
-         *   coinInType: "0x<coinA>",
-         *   coinOutAmount: BigInt(1000000),
-         *   coinOutType: "0x<coinB>"
-         * });
-         * ```
-         */
-        this.getTradeAmountIn = (inputs) => {
-            const pool = utils_1.Helpers.deepCopy(this.pool);
-            const coinInPoolBalance = pool.coins[inputs.coinInType].balance;
-            const coinOutPoolBalance = pool.coins[inputs.coinOutType].balance;
-            if (Number(inputs.coinOutAmount) / Number(coinOutPoolBalance) >=
-                _1.Pools.constants.bounds.maxTradePercentageOfPoolBalance -
-                    Pool.constants.percentageBoundsMarginOfError)
-                throw new Error("coinOutAmount / coinOutPoolBalance >= maxTradePercentageOfPoolBalance");
-            const coinInAmount = cmmmCalculations_1.CmmmCalculations.calcInGivenOut(pool, inputs.coinInType, inputs.coinOutType, inputs.coinOutAmount);
-            if (coinInAmount <= 0)
-                throw new Error("coinInAmount <= 0");
-            if (Number(coinInAmount) / Number(coinInPoolBalance) >=
-                _1.Pools.constants.bounds.maxTradePercentageOfPoolBalance -
-                    Pool.constants.percentageBoundsMarginOfError)
-                throw new Error("coinInAmount / coinInPoolBalance >= maxTradePercentageOfPoolBalance");
-            const coinInAmountWithoutFees = this.getAmountWithoutDAOFee({
-                amount: _1.Pools.getAmountWithoutProtocolFees({
-                    amount: coinInAmount,
-                }),
-            });
-            return coinInAmountWithoutFees;
-        };
-        /**
-         * Calculates how many LP tokens you receive for providing liquidity
-         * in specific coin amounts. Also returns a ratio for reference.
-         *
-         * @param inputs - Contains the amounts in for each coin in the pool.
-         * @returns An object with `lpAmountOut` and `lpRatio`.
-         *
-         * @example
-         * ```typescript
-         * const depositCalc = pool.getDepositLpAmountOut({
-         *   amountsIn: { "0x<coinA>": BigInt(1000000), "0x<coinB>": BigInt(500000) },
-         * });
-         * console.log(depositCalc.lpAmountOut, depositCalc.lpRatio);
-         * ```
-         */
-        this.getDepositLpAmountOut = (inputs) => {
-            const calcedLpRatio = cmmmCalculations_1.CmmmCalculations.calcDepositFixedAmounts(this.pool, Object.entries(inputs.amountsIn).reduce((acc, [coin, amount]) => (Object.assign(Object.assign({}, acc), { [coin]: this.getAmountWithDAOFee({ amount }) })), {}));
-            if (calcedLpRatio >= utils_1.Casting.Fixed.fixedOneB)
-                throw new Error("lpRatio >= 1");
-            const lpRatio = utils_1.Casting.bigIntToFixedNumber(calcedLpRatio);
-            const lpAmountOut = BigInt(Math.floor(Number(this.pool.lpCoinSupply) * (1 / lpRatio - 1)));
-            return {
-                lpAmountOut,
-                lpRatio,
-            };
-        };
-        /**
-         * Calculates how many coins a user will receive when withdrawing a specific ratio or LP amount.
-         * This method is used in multi-coin withdrawals where you specify how much of each coin you want.
-         *
-         * @param inputs - The LP ratio and an object specifying direction amounts for each coin.
-         * @returns A `CoinsToBalance` object with final amounts out, factoring in DAO fees.
-         *
-         * @example
-         * ```typescript
-         * const outAmounts = pool.getWithdrawAmountsOut({
-         *   lpRatio: 0.1,
-         *   amountsOutDirection: { "0x<coinA>": BigInt(500000) },
-         * });
-         * console.log(outAmounts);
-         * ```
-         */
-        this.getWithdrawAmountsOut = (inputs) => {
-            const amountsOut = cmmmCalculations_1.CmmmCalculations.calcWithdrawFlpAmountsOut(this.pool, inputs.amountsOutDirection, inputs.lpRatio);
-            for (const coin of Object.keys(amountsOut)) {
-                if (!(coin in inputs.amountsOutDirection) ||
-                    inputs.amountsOutDirection[coin] <= BigInt(0))
-                    continue;
-                const amountOut = amountsOut[coin];
-                if (amountOut <= 0) {
-                    throw new Error(`amountsOut[${coin}] <= 0`);
-                }
-                if (Number(amountOut) / Number(this.pool.coins[coin].balance) >=
-                    _1.Pools.constants.bounds.maxWithdrawPercentageOfPoolBalance) {
-                    throw new Error("coinOutAmount / coinOutPoolBalance >= maxWithdrawPercentageOfPoolBalance");
-                }
-                amountsOut[coin] = this.getAmountWithDAOFee({ amount: amountOut });
-            }
-            return amountsOut;
-        };
-        /**
-         * A simplified multi-coin withdraw approach: calculates all outputs by proportion of the
-         * user's LP share among selected coin types. Useful for approximate or "blind" all-coin out logic.
-         *
-         * @param inputs - Contains the `lpCoinAmountIn` to burn, and which coin types to receive.
-         * @returns A record mapping coin type => final amounts out.
-         */
-        this.getWithdrawAmountsOutSimple = (inputs) => {
-            const { lpCoinAmountIn, coinTypesOut, referral } = inputs;
-            const lpCoinSupply = this.pool.lpCoinSupply;
-            let withdrawAmountsEstimates = {};
-            coinTypesOut.forEach((poolCoin) => {
-                const poolCoinAmountInPool = this.pool.coins[utils_1.Helpers.addLeadingZeroesToType(poolCoin)]
-                    .balance;
-                const poolCoinAmount = Number(poolCoinAmountInPool) *
-                    (Number(lpCoinAmountIn) / Number(lpCoinSupply));
-                withdrawAmountsEstimates[utils_1.Helpers.addLeadingZeroesToType(poolCoin)] =
-                    BigInt(Math.floor(poolCoinAmount));
-            });
-            const lpRatio = this.getMultiCoinWithdrawLpRatio({
-                lpCoinAmountIn,
-            });
-            const amountsOut = this.getWithdrawAmountsOut({
-                lpRatio,
-                amountsOutDirection: withdrawAmountsEstimates,
-                referral,
-            });
-            for (const coin of Object.keys(amountsOut)) {
-                if (!coinTypesOut
-                    .map((coinOut) => utils_1.Helpers.addLeadingZeroesToType(coinOut))
-                    .includes(coin))
-                    continue;
-                const amountOut = amountsOut[coin];
-                if (amountOut <= BigInt(0))
-                    throw new Error(`amountsOut[${coin}] <= 0 `);
-                if (amountOut / this.pool.coins[coin].balance >=
-                    _1.Pools.constants.bounds.maxWithdrawPercentageOfPoolBalance)
-                    throw new Error("coinOutAmount / coinOutPoolBalance >= maxWithdrawPercentageOfPoolBalance");
-                amountsOut[coin] = this.getAmountWithDAOFee({
-                    amount: amountOut,
-                });
-            }
-            return amountsOut;
-        };
-        /**
-         * Calculates how many coins you get when withdrawing **all** coin types from the pool,
-         * given a ratio. This is typically used for proportionate withdrawal.
-         *
-         * @param inputs - Includes `lpRatio`, the portion of your LP to burn (0 < ratio < 1).
-         * @returns A record of coin type => amounts out, after factoring in any fees.
-         *
-         * @example
-         * ```typescript
-         * const allOut = pool.getAllCoinWithdrawAmountsOut({ lpRatio: 0.1 });
-         * console.log(allOut); // amounts for each coin
-         * ```
-         */
-        this.getAllCoinWithdrawAmountsOut = (inputs) => {
-            if (inputs.lpRatio >= 1)
-                throw new Error("lpRatio >= 1");
-            const amountsOut = Object.entries(this.pool.coins).reduce((acc, [coin, info]) => {
-                return Object.assign(Object.assign({}, acc), { [coin]: this.getAmountWithDAOFee({
-                        amount: BigInt(Math.floor(Number(info.balance) * inputs.lpRatio)),
-                    }) });
-            }, {});
-            return amountsOut;
-        };
-        /**
-         * For multi-coin withdraw, calculates the ratio of how much LP you are burning
-         * relative to the total supply. e.g. if user burns 100 of 1000 supply => ratio 0.1.
-         *
-         * @param inputs - Contains the `lpCoinAmountIn` to burn.
-         * @returns A float ratio (0 < ratio < 1).
-         */
-        this.getMultiCoinWithdrawLpRatio = (inputs) => Number(this.pool.lpCoinSupply - inputs.lpCoinAmountIn) /
-            Number(this.pool.lpCoinSupply);
-        /**
-         * For an all-coin withdraw, calculates the ratio of how much LP is burned
-         * relative to total supply. e.g. if user burns 50 of 200 supply => ratio 0.25.
-         *
-         * @param inputs - Contains the `lpCoinAmountIn`.
-         * @returns A float ratio, typically 0 < ratio < 1.
-         */
-        this.getAllCoinWithdrawLpRatio = (inputs) => Number(inputs.lpCoinAmountIn) / Number(this.pool.lpCoinSupply);
-        // =========================================================================
-        //  Getters
-        // =========================================================================
-        /**
-         * Returns an array of coin types in ascending lexicographic order
-         * for the coins contained in this pool.
-         *
-         * @returns An array of coin type strings.
-         */
-        this.coins = () => {
-            return Object.keys(this.pool.coins).sort((a, b) => a.localeCompare(b));
-        };
-        /**
-         * Returns an array of `PoolCoin` objects, one for each coin in this pool,
-         * sorted lexicographically by coin type.
-         *
-         * @returns An array of `PoolCoin`.
-         */
-        this.poolCoins = () => {
-            return Object.entries(this.pool.coins)
-                .sort((a, b) => a[0].localeCompare(b[0]))
-                .map((data) => data[1]);
-        };
-        /**
-         * Returns an array of `[CoinType, PoolCoin]` pairs, sorted by coin type.
-         *
-         * @returns An array of coin-type => `PoolCoin` pairs.
-         */
-        this.poolCoinEntries = () => {
-            return Object.entries(this.pool.coins).sort((a, b) => a[0].localeCompare(b[0]));
-        };
-        /**
-         * Returns the current DAO fee percentage, if configured (0 < fee <= 100%).
-         *
-         * @returns A decimal fraction representing the fee (e.g., 0.01 = 1%) or `undefined`.
-         */
-        this.daoFeePercentage = () => {
-            return this.pool.daoFeePoolObject
-                ? utils_1.Casting.bpsToPercentage(this.pool.daoFeePoolObject.feeBps)
-                : undefined;
-        };
-        /**
-         * Returns the Sui address that currently receives the DAO fee portion of
-         * pool trades, or `undefined` if no DAO fee is configured.
-         *
-         * @returns The DAO fee recipient address.
-         */
-        this.daoFeeRecipient = () => {
-            var _a;
-            return (_a = this.pool.daoFeePoolObject) === null || _a === void 0 ? void 0 : _a.feeRecipient;
-        };
-        // =========================================================================
-        //  Private Helpers
-        // =========================================================================
-        /**
-         * Applies the DAO fee (if present) to a given `amount`, effectively reducing
-         * that amount by the fee fraction. e.g. if fee is 2%, it returns 98% of the input.
-         *
-         * @param inputs - Contains `amount` as a bigint.
-         * @returns The post-fee amount as a bigint.
-         */
-        this.getAmountWithDAOFee = (inputs) => {
-            const daoFeePercentage = this.daoFeePercentage();
-            if (!daoFeePercentage)
-                return inputs.amount;
-            return BigInt(Math.floor(Number(inputs.amount) * (1 - daoFeePercentage)));
-        };
-        /**
-         * The inverse operation of `getAmountWithDAOFee`, used in internal calculations
-         * when we need to back out how much input was needed prior to the fee cut.
-         *
-         * @param inputs - Contains `amount` as a bigint.
-         * @returns The pre-fee amount as a bigint.
-         */
-        this.getAmountWithoutDAOFee = (inputs) => {
-            const daoFeePercentage = this.daoFeePercentage();
-            if (!daoFeePercentage)
-                return inputs.amount;
-            return BigInt(Math.floor(Number(inputs.amount) * (1 / (1 - daoFeePercentage))));
-        };
-        /**
-         * Provides an instance of the Pools provider from `AftermathApi`.
-         * Throws an error if not defined.
-         */
-        this.useProvider = () => {
-            var _a;
-            const provider = (_a = this.Provider) === null || _a === void 0 ? void 0 : _a.Pools();
-            if (!provider)
-                throw new Error("missing AftermathApi Provider");
-            return provider;
-        };
-        this.pool = pool;
-    }
-    // =========================================================================
-    //  Transactions
-    // =========================================================================
-    /**
-     * Builds or fetches a deposit transaction to add liquidity to this pool.
-     * The resulting `Transaction` can be signed and submitted by the user.
-     *
-     * @param inputs - The deposit parameters including coin amounts, slippage, etc.
-     * @returns A `Transaction` to deposit funds into the pool.
-     *
-     * @example
-     * ```typescript
-     * const depositTx = await pool.getDepositTransaction({
-     *   walletAddress: "0x...",
-     *   amountsIn: { "0x<coin>": BigInt(1000000) },
-     *   slippage: 0.01,
-     * });
-     * ```
-     */
-    getDepositTransaction(inputs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.useProvider().fetchBuildDepositTx(Object.assign(Object.assign({}, inputs), { pool: this }));
-        });
-    }
-    /**
-     * Builds or fetches a withdrawal transaction to remove liquidity from this pool.
-     *
-     * @param inputs - The parameters specifying how much LP is burned, desired coins out, slippage, etc.
-     * @returns A `Transaction` to withdraw funds from the pool.
-     *
-     * @example
-     * ```typescript
-     * const withdrawTx = await pool.getWithdrawTransaction({
-     *   walletAddress: "0x...",
-     *   amountsOutDirection: {
-     *     "0x<coin>": BigInt(500000),
-     *   },
-     *   lpCoinAmount: BigInt(1000000),
-     *   slippage: 0.01,
-     * });
-     * ```
-     */
-    getWithdrawTransaction(inputs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.useProvider().fetchBuildWithdrawTx(Object.assign(Object.assign({}, inputs), { pool: this }));
-        });
-    }
-    /**
-     * Builds or fetches a transaction to withdraw all coin types from this pool,
-     * effectively "burning" an LP position in exchange for multiple coin outputs.
-     *
-     * @param inputs - The parameters specifying how much LP to burn.
-     * @returns A `Transaction` to withdraw all coins from the pool in proportion.
-     *
-     * @example
-     * ```typescript
-     * const allCoinWithdrawTx = await pool.getAllCoinWithdrawTransaction({
-     *   walletAddress: "0x...",
-     *   lpCoinAmount: BigInt(500000),
-     * });
-     * ```
-     */
-    getAllCoinWithdrawTransaction(inputs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.useProvider().fetchBuildAllCoinWithdrawTx(Object.assign(Object.assign({}, inputs), { pool: this }));
-        });
-    }
-    /**
-     * Builds or fetches a trade transaction to swap between two coin types in this pool.
-     *
-     * @param inputs - The trade parameters including coin in/out, amounts, slippage, etc.
-     * @returns A `Transaction` that can be signed and executed for the swap.
-     *
-     * @example
-     * ```typescript
-     * const tradeTx = await pool.getTradeTransaction({
-     *   walletAddress: "0x...",
-     *   coinInType: "0x<coinA>",
-     *   coinInAmount: BigInt(1000000),
-     *   coinOutType: "0x<coinB>",
-     *   slippage: 0.005,
-     * });
-     * ```
-     */
-    getTradeTransaction(inputs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.useProvider().fetchBuildTradeTx(Object.assign(Object.assign({}, inputs), { pool: this }));
-        });
-    }
-    /**
-     * Builds a transaction to update the DAO fee percentage for this pool,
-     * if it has a DAO fee configured. The user must own the appropriate
-     * `daoFeePoolOwnerCap`.
-     *
-     * @param inputs - Includes user wallet, `daoFeePoolOwnerCapId`, and the new fee percentage.
-     * @returns A `Transaction` that can be signed to update the DAO fee on chain.
-     * @throws If this pool has no DAO fee configuration.
-     *
-     * @example
-     * ```typescript
-     * const tx = await pool.getUpdateDaoFeeTransaction({
-     *   walletAddress: "0x...",
-     *   daoFeePoolOwnerCapId: "0x<capId>",
-     *   newFeePercentage: 0.01, // 1%
-     * });
-     * ```
-     */
-    getUpdateDaoFeeTransaction(inputs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const daoFeePoolId = (_a = this.pool.daoFeePoolObject) === null || _a === void 0 ? void 0 : _a.objectId;
-            if (!daoFeePoolId)
-                throw new Error("this pool has no DAO fee");
-            return this.useProvider().buildDaoFeePoolUpdateFeeBpsTx(Object.assign(Object.assign({}, inputs), { daoFeePoolId, lpCoinType: this.pool.lpCoinType, newFeeBps: utils_1.Casting.percentageToBps(inputs.newFeePercentage) }));
-        });
-    }
-    /**
-     * Builds a transaction to update the DAO fee recipient for this pool,
-     * if it has a DAO fee configured. The user must own the appropriate
-     * `daoFeePoolOwnerCap`.
-     *
-     * @param inputs - Includes user wallet, `daoFeePoolOwnerCapId`, and the new fee recipient.
-     * @returns A `Transaction` that can be signed to update the DAO fee recipient on chain.
-     * @throws If this pool has no DAO fee configuration.
-     *
-     * @example
-     * ```typescript
-     * const tx = await pool.getUpdateDaoFeeRecipientTransaction({
-     *   walletAddress: "0x...",
-     *   daoFeePoolOwnerCapId: "0x<capId>",
-     *   newFeeRecipient: "0x<recipient>",
-     * });
-     * ```
-     */
-    getUpdateDaoFeeRecipientTransaction(inputs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const daoFeePoolId = (_a = this.pool.daoFeePoolObject) === null || _a === void 0 ? void 0 : _a.objectId;
-            if (!daoFeePoolId)
-                throw new Error("this pool has no DAO fee");
-            return this.useProvider().buildDaoFeePoolUpdateFeeRecipientTx(Object.assign(Object.assign({}, inputs), { daoFeePoolId, lpCoinType: this.pool.lpCoinType, newFeeRecipient: utils_1.Helpers.addLeadingZeroesToType(inputs.newFeeRecipient) }));
-        });
-    }
-    // =========================================================================
-    //  Inspections
-    // =========================================================================
-    /**
-     * Fetches comprehensive pool statistics (volume, TVL, fees, APR, etc.) from the Aftermath API.
-     * Also caches the result in `this.stats`.
-     *
-     * @returns A promise resolving to `PoolStats` object.
-     *
-     * @example
-     * ```typescript
-     * const stats = await pool.getStats();
-     * console.log(stats.volume, stats.fees, stats.apr);
-     * ```
-     */
-    getStats() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const stats = yield this.fetchApi("stats");
-            this.setStats(stats);
-            return stats;
-        });
-    }
-    /**
-     * Caches the provided stats object into `this.stats`.
-     *
-     * @param stats - The `PoolStats` object to store.
-     */
-    setStats(stats) {
-        this.stats = stats;
-    }
-    /**
-     * Fetches an array of volume data points for a specified timeframe.
-     * This is often used for charting or historical references.
-     *
-     * @param inputs - Contains a `timeframe` key, such as `"1D"` or `"1W"`.
-     * @returns A promise resolving to an array of `PoolDataPoint`.
-     *
-     * @example
-     * ```typescript
-     * const volumeData = await pool.getVolumeData({ timeframe: "1D" });
-     * console.log(volumeData); // e.g. [{ time: 1686000000, value: 123.45 }, ...]
-     * ```
-     */
-    getVolumeData(inputs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.fetchApi(`volume/${inputs.timeframe}`);
-        });
-    }
-    /**
-     * Fetches an array of fee data points for a specified timeframe.
-     *
-     * @param inputs - Contains a `timeframe` key, e.g., `"1D"` or `"1W"`.
-     * @returns A promise resolving to an array of `PoolDataPoint`.
-     *
-     * @example
-     * ```typescript
-     * const feeData = await pool.getFeeData({ timeframe: "1D" });
-     * console.log(feeData);
-     * ```
-     */
-    getFeeData(inputs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.fetchApi(`fees/${inputs.timeframe}`);
-        });
-    }
-    // =========================================================================
-    //  Events
-    // =========================================================================
-    /**
-     * Fetches user interaction events (deposit/withdraw) with this pool, optionally paginated.
-     *
-     * @param inputs - Includes user `walletAddress` and optional pagination fields.
-     * @returns A promise that resolves to `PoolDepositEvent | PoolWithdrawEvent` objects with a cursor if more exist.
-     *
-     * @example
-     * ```typescript
-     * const events = await pool.getInteractionEvents({ walletAddress: "0x...", limit: 10 });
-     * console.log(events.events, events.nextCursor);
-     * ```
-     */
-    getInteractionEvents(inputs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.fetchApiIndexerEvents("interaction-events-by-user", inputs);
-        });
-    }
-}
-exports.Pool = Pool;
-/**
- * Internal margin of error used in trade calculations to prevent
- * exceeding maximum allowed percentages of pool balances.
- */
-Pool.constants = {
-    percentageBoundsMarginOfError: 0.001, // 0.1%
-};