aftermath-ts-sdk 1.1.97 → 1.2.0-refactor.1

package/dist/packages/pools/api/poolsApi.js

@@ -8,9 +8,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PoolsApi = void 0;
 const transactions_1 = require("@mysten/sui/transactions");
@@ -19,10 +16,6 @@ const casting_1 = require("../../../general/utils/casting");
 const pools_1 = require("../pools");
 const utils_2 = require("../../../general/utils");
 const coin_1 = require("../../coin");
-const dayjs_1 = __importDefault(require("dayjs"));
-const poolsApiCasting_1 = require("./poolsApiCasting");
-const duration_1 = __importDefault(require("dayjs/plugin/duration"));
-const fixedUtils_1 = require("../../../general/utils/fixedUtils");
 const eventsApiHelpers_1 = require("../../../general/apiHelpers/eventsApiHelpers");
 const bcs_1 = require("@mysten/sui/bcs");
 /**
@@ -49,36 +42,6 @@ class PoolsApi {
         // =========================================================================
         //  Objects
         // =========================================================================
-        // TODO: make caches shared across pool object fetching funcs
-        /**
-         * Fetches a pool object by its object ID.
-         * @async
-         * @param {ObjectId} inputs.objectId - The object ID of the pool to fetch.
-         * @returns {Promise<PoolObject>} A promise that resolves to the fetched pool object.
-         */
-        this.fetchPool = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            return (yield this.fetchPools({ objectIds: [inputs.objectId] }))[0];
-        });
-        this.fetchPools = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            const poolIds = inputs.objectIds.map((objectId) => utils_2.Helpers.addLeadingZeroesToType(objectId));
-            const response = yield this.Provider.indexerCaller.fetchIndexer("pools", {
-                pool_ids: poolIds,
-            });
-            const pools = poolsApiCasting_1.PoolsApiCasting.poolObjectsFromIndexerResponse(response);
-            return poolIds.map((objectId) => pools.find((pool) => pool.objectId ===
-                utils_2.Helpers.addLeadingZeroesToType(objectId)
-            // TODO: handle this error case better
-            ));
-        });
-        /**
-         * Fetches all pool objects.
-         * @async
-         * @returns {Promise<PoolObject[]>} A promise that resolves to an array of all fetched pool objects.
-         */
-        this.fetchAllPools = () => __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.Provider.indexerCaller.fetchIndexer("pools", {});
-            return poolsApiCasting_1.PoolsApiCasting.poolObjectsFromIndexerResponse(response);
-        });
         this.fetchOwnedDaoFeePoolOwnerCaps = (inputs) => __awaiter(this, void 0, void 0, function* () {
             const { walletAddress } = inputs;
             if (!this.objectTypes.daoFeePoolOwnerCap)
@@ -439,35 +402,6 @@ class PoolsApi {
         // =========================================================================
         //  Transaction Builders
         // =========================================================================
-        /**
-         * Fetches a transaction block for creating a new pool.
-         * @async
-         * @param {SuiAddress} inputs.walletAddress - The wallet address of the user creating the pool.
-         * @param {CoinType} inputs.lpCoinType - The coin type of the LP token.
-         * @param {PoolCreationLpCoinMetadata} inputs.lpCoinMetadata - The metadata of the LP token.
-         * @param {{ coinType: CoinType; weight: Percentage; decimals?: CoinDecimal; tradeFeeIn: Percentage; initialDeposit: Balance; }[]} inputs.coinsInfo - An array of objects containing information about the coins in the pool.
-         * @param {PoolName} inputs.poolName - The name of the pool.
-         * @param {0 | 1} inputs.poolFlatness - The flatness of the pool.
-         * @param {ObjectId} inputs.createPoolCapId - The object ID of the create pool cap.
-         * @param {boolean} inputs.respectDecimals - Whether to respect decimals.
-         * @param {CoinDecimal} [inputs.forceLpDecimals] - The decimal places to force for the LP token.
-         * @param {boolean} [inputs.isSponsoredTx] - Whether the transaction is sponsored.
-         * @returns {Promise<Transaction>} A promise that resolves to the fetched transaction block.
-         */
-        this.fetchCreatePoolTx = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            // NOTE: these are temp defaults down below since some selections are currently disabled in contracts
-            return this.fetchBuildCreatePoolTx(Object.assign(Object.assign({}, inputs), { lpCoinIconUrl: (_a = inputs.lpCoinMetadata.iconUrl) !== null && _a !== void 0 ? _a : "", poolFlatness: inputs.poolFlatness === 1 ? casting_1.Casting.Fixed.fixedOneB : BigInt(0), coinsInfo: inputs.coinsInfo.map((info, index) => {
-                    let weight = casting_1.Casting.numberToFixedBigInt(info.weight);
-                    if (index === 0) {
-                        const otherWeightsSum = utils_2.Helpers.sumBigInt(inputs.coinsInfo
-                            .slice(1)
-                            .map((info) => casting_1.Casting.numberToFixedBigInt(info.weight)));
-                        weight = casting_1.Casting.Fixed.fixedOneB - otherWeightsSum;
-                    }
-                    return Object.assign(Object.assign({}, info), { weight, tradeFeeIn: casting_1.Casting.numberToFixedBigInt(info.tradeFeeIn), depositFee: BigInt(0), withdrawFee: BigInt(0), tradeFeeOut: BigInt(0) });
-                }) }));
-        });
         /**
          * Fetches a transaction block for trading in a pool.
          * @async
@@ -716,604 +650,9 @@ class PoolsApi {
             tx.transferObjects([upgradeCap], inputs.walletAddress);
             return tx;
         };
-        /**
-         * Fetches and builds a transaction for creating a new liquidity pool.
-         * @param inputs An object containing the necessary inputs for creating the pool.
-         * @returns A Promise that resolves to a Transaction object representing the built transaction.
-         */
-        this.fetchBuildCreatePoolTx = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            const { coinsInfo, isSponsoredTx, burnLpCoin, lpCoinType, daoFeeInfo } = inputs;
-            const tx = new transactions_1.Transaction();
-            tx.setSender(inputs.walletAddress);
-            // TODO: make this fetching work
-            // const createPoolCapId =
-            // 	inputs.createPoolCapId !== undefined
-            // 		? inputs.createPoolCapId
-            // 		: (
-            // 				await this.Provider.Objects().fetchObjectsOfTypeOwnedByAddress(
-            // 					inputs.walletAddress,
-            // 					`${this.addresses.pools.packages.cmmm}::${PoolsApi.constants.moduleNames.pool}::CreatePoolCap<${inputs.lpCoinType}>`
-            // 				)
-            // 		  )[0].data?.objectId;
-            // if (createPoolCapId === undefined)
-            // 	throw new Error(
-            // 		"no CreatePoolCap for LP Coin Type found owned by address"
-            // 	);
-            coinsInfo.sort((a, b) => {
-                const coinA = a.coinType.toUpperCase();
-                const coinB = b.coinType.toUpperCase();
-                return coinA < coinB ? -1 : coinA > coinB ? 1 : 0;
-            });
-            const coinTypes = coinsInfo.map((coin) => coin.coinType);
-            const lpCoinDescription = yield this.createLpCoinMetadataDescription(Object.assign(Object.assign({}, inputs), { coinTypes }));
-            const coinArgs = yield this.Provider.Coin().fetchCoinsWithAmountTx(Object.assign(Object.assign({ tx }, inputs), { coinTypes, coinAmounts: coinsInfo.map((info) => info.initialDeposit), isSponsoredTx }));
-            const createPoolTxArgs = Object.assign(Object.assign({ tx }, inputs), { 
-                // createPoolCapId,
-                coinsInfo: coinsInfo.map((info, index) => {
-                    return Object.assign(Object.assign({}, info), { coinId: coinArgs[index] });
-                }), lpCoinDescription });
-            if (daoFeeInfo) {
-                if (!this.objectTypes.daoFeePool)
-                    throw new Error("dao fee pool addresses have not been set in provider");
-                const [poolId, lpCoinId] = this.createPoolTx(createPoolTxArgs);
-                const [daoFeePoolId, daoFeePoolOwnerCapId] = this.daoFeePoolNewTx({
-                    tx,
-                    poolId,
-                    lpCoinType,
-                    feeRecipient: daoFeeInfo.feeRecipient,
-                    feeBps: casting_1.Casting.percentageToBps(daoFeeInfo.feePercentage),
-                });
-                this.Provider.Objects().publicShareObjectTx({
-                    tx,
-                    object: daoFeePoolId,
-                    objectType: `${this.objectTypes.daoFeePool}<${lpCoinType}>`,
-                });
-                if (burnLpCoin) {
-                    this.Provider.Objects().burnObjectTx({
-                        tx,
-                        object: lpCoinId,
-                    });
-                    tx.transferObjects([daoFeePoolOwnerCapId], inputs.walletAddress);
-                }
-                else {
-                    tx.transferObjects([lpCoinId, daoFeePoolOwnerCapId], inputs.walletAddress);
-                }
-            }
-            else {
-                if (burnLpCoin) {
-                    const [poolId, lpCoinId] = this.createPoolTx(createPoolTxArgs);
-                    this.Provider.Objects().publicShareObjectTx({
-                        tx,
-                        object: poolId,
-                        objectType: `${this.objectTypes.pool}<${lpCoinType}>`,
-                    });
-                    this.Provider.Objects().burnObjectTx({
-                        tx,
-                        object: lpCoinId,
-                    });
-                }
-                else {
-                    this.createPoolTx(Object.assign(Object.assign({}, createPoolTxArgs), { withTransfer: true }));
-                }
-            }
-            return tx;
-        });
         this.buildDaoFeePoolUpdateFeeBpsTx = utils_2.Helpers.transactions.createBuildTxFunc(this.daoFeePoolUpdateFeeBpsTx);
         this.buildDaoFeePoolUpdateFeeRecipientTx = utils_2.Helpers.transactions.createBuildTxFunc(this.daoFeePoolUpdateFeeRecipientTx);
         // =========================================================================
-        //  Inspections
-        // =========================================================================
-        /**
-         * Fetches the pool object ID for a given LP coin type.
-         * @param inputs - An object containing the LP coin type.
-         * @returns A Promise that resolves to the pool object ID.
-         */
-        this.fetchPoolObjectIdForLpCoinType = this.Provider.withCache({
-            key: "fetchPoolObjectIdForLpCoinType",
-            expirationSeconds: -1,
-            callback: (inputs) => __awaiter(this, void 0, void 0, function* () {
-                if (!pools_1.Pools.isPossibleLpCoinType(inputs))
-                    return "";
-                const tx = new transactions_1.Transaction();
-                this.poolObjectIdForLpCoinTypeTx(Object.assign({ tx }, inputs));
-                const bytes = yield this.Provider.Inspections().fetchFirstBytesFromTxOutput({
-                    tx,
-                });
-                return casting_1.Casting.addressFromBytes(bytes);
-            }),
-        });
-        // TODO: add cache and generalize logic
-        // public fetchPoolObjectIdForLpCoinTypes = this.Provider.withCache({
-        // 	key: "fetchPoolObjectIdForLpCoinTypes",
-        // 	expirationSeconds: -1,
-        // 	callback: async (inputs: {
-        // 		lpCoinType: CoinType;
-        // 	}): Promise<ObjectId | undefined> => {
-        // 		if (!Pools.isPossibleLpCoinType(inputs)) return "";
-        // 		const tx = new Transaction();
-        // 		this.poolObjectIdForLpCoinTypeTx({ tx, ...inputs });
-        // 		const bytes =
-        // 			await this.Provider.Inspections().fetchFirstBytesFromTxOutput({
-        // 				tx,
-        // 			});
-        // 		return Casting.addressFromBytes(bytes);
-        // 	},
-        // });
-        this.fetchIsLpCoinType = this.Provider.withCache({
-            key: "fetchIsLpCoinType",
-            expirationSeconds: -1,
-            callback: (inputs) => __awaiter(this, void 0, void 0, function* () {
-                const { lpCoinType } = inputs;
-                const poolId = yield this.fetchPoolObjectIdForLpCoinType({
-                    lpCoinType,
-                });
-                if (!poolId)
-                    return false;
-                return true;
-            }),
-        });
-        /**
-         * Fetches the list of unique supported coins across all pools.
-         * @returns {Promise<CoinType[]>} A promise that resolves to an array of unique supported coins.
-         */
-        this.fetchSupportedCoins = () => __awaiter(this, void 0, void 0, function* () {
-            const pools = yield this.Provider.Pools().fetchAllPools();
-            const allCoins = pools
-                .map((pool) => Object.keys(pool.coins))
-                .reduce((prev, cur) => [...prev, ...cur], []);
-            const uniqueCoins = utils_2.Helpers.uniqueArray(allCoins);
-            return uniqueCoins;
-        });
-        /**
-         * Fetches the owned LP coin positions for a given wallet address.
-         * @param inputs An object containing the wallet address.
-         * @returns A Promise that resolves to an array of PoolLpInfo objects.
-         */
-        this.fetchOwnedLpCoinPositions = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            const { walletAddress } = inputs;
-            const [coinsToBalance, pools] = yield Promise.all([
-                this.Provider.Wallet().fetchAllCoinBalances({
-                    walletAddress,
-                }),
-                this.fetchAllPools(),
-            ]);
-            let lpInfo = [];
-            for (const pool of pools) {
-                const lpCoinType = utils_2.Helpers.addLeadingZeroesToType(pool.lpCoinType);
-                if (!(lpCoinType in coinsToBalance))
-                    continue;
-                lpInfo.push({
-                    lpCoinType,
-                    poolId: pool.objectId,
-                    balance: coinsToBalance[lpCoinType],
-                });
-            }
-            return lpInfo;
-        });
-        // =========================================================================
-        //  Stats
-        // =========================================================================
-        /**
-         * Fetches statistics for a given pool.
-         * @param inputs An object containing the pool, trade events within a certain time frame, coins to price, and coins to decimals.
-         * @returns A Promise that resolves to a PoolStats object containing the volume, TVL, supply per LP token, LP token price, fees, and APY.
-         */
-        this.fetchPoolStats = this.Provider.withCache({
-            key: "fetchPoolStats",
-            expirationSeconds: 60 * 5,
-            callback: (inputs) => __awaiter(this, void 0, void 0, function* () {
-                const { poolId } = inputs;
-                const pool = yield this.fetchPool({ objectId: poolId });
-                const poolCoins = pool.coins;
-                const poolCoinTypes = Object.keys(pool.coins);
-                // TODO: move common milliseconds to constants or use dayjs
-                const durationMs24hrs = 86400000;
-                const [coinsToPrice, coinsToDecimals, volumes] = yield Promise.all([
-                    this.Provider.Prices().fetchCoinsToPrice({
-                        coins: poolCoinTypes,
-                    }),
-                    this.Provider.Coin().fetchCoinsToDecimals({
-                        coins: poolCoinTypes,
-                    }),
-                    this.fetchPoolVolume({
-                        poolId: pool.objectId,
-                        durationMs: durationMs24hrs,
-                    }),
-                ]);
-                const volume = utils_2.Helpers.calcIndexerVolumeUsd({
-                    volumes,
-                    coinsToDecimals,
-                    coinsToPrice,
-                });
-                const tvl = this.calcPoolTvl({
-                    poolCoins: pool.coins,
-                    coinsToPrice,
-                    coinsToDecimals,
-                });
-                const supplyPerLps = this.calcPoolSupplyPerLps(poolCoins, pool.lpCoinSupply);
-                const lpPrice = this.calcPoolLpPrice({
-                    lpCoinDecimals: pool.lpCoinDecimals,
-                    lpCoinSupply: pool.lpCoinSupply,
-                    tvl,
-                });
-                // this is okay since all trade fees are currently the same for every coin
-                const firstCoin = Object.values(pool.coins)[0];
-                const fees = volume *
-                    fixedUtils_1.FixedUtils.directCast(firstCoin.tradeFeeIn + firstCoin.tradeFeeOut);
-                const apr = this.calcApr({
-                    fees24Hours: fees,
-                    tvl,
-                });
-                return {
-                    volume,
-                    tvl,
-                    supplyPerLps,
-                    lpPrice,
-                    fees,
-                    apr,
-                };
-            }),
-        });
-        /**
-         * Fetches the pool volume for a given pool and duration.
-         * @param inputs - The inputs for fetching the pool volume.
-         * @returns A Promise that resolves to an array of pool volumes.
-         */
-        this.fetchPoolVolume = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            const { poolId, durationMs } = inputs;
-            const response = yield this.Provider.indexerCaller.fetchIndexer(`pools/${poolId}/swap-volume/${durationMs}`);
-            return response.map((data) => (Object.assign(Object.assign({}, data), { coinTypeIn: utils_2.Helpers.addLeadingZeroesToType(data.coinTypeIn), coinTypeOut: utils_2.Helpers.addLeadingZeroesToType(data.coinTypeOut) })));
-        });
-        /**
-         * Fetches the total volume of swaps within a specified duration.
-         * @param inputs - The inputs for fetching the total volume.
-         * @returns A Promise that resolves to an array of total volumes.
-         */
-        this.fetchTotalVolume = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            const { durationMs } = inputs;
-            return this.Provider.indexerCaller.fetchIndexer(`pools/total-swap-volume/${durationMs}`);
-        });
-        /**
-         * Calculates the total value locked (TVL) for a given pool, based on its current balances and prices.
-         * @param inputs - An object containing the pool's coins, their prices, and their decimal places.
-         * @returns The total value locked (TVL) for the pool.
-         */
-        this.calcPoolTvl = (inputs) => {
-            const { poolCoins, coinsToPrice, coinsToDecimals } = inputs;
-            let tvl = 0;
-            for (const [poolCoinType, poolCoin] of Object.entries(poolCoins)) {
-                const amountWithDecimals = coin_1.Coin.balanceWithDecimals(poolCoin.balance, coinsToDecimals[poolCoinType]);
-                const price = coinsToPrice[poolCoinType];
-                tvl += amountWithDecimals * (price < 0 ? 0 : price);
-            }
-            return tvl;
-        };
-        this.fetchCalcPoolVolume24hrs = this.Provider.withCache({
-            key: "fetchPool",
-            expirationSeconds: 300,
-            callback: (inputs) => __awaiter(this, void 0, void 0, function* () {
-                const { poolId } = inputs;
-                const durationMs = 86400000; // 24hrs
-                const volumes = yield this.fetchPoolVolume({
-                    durationMs,
-                    poolId,
-                });
-                const coins = utils_2.Helpers.uniqueArray([
-                    ...volumes.map((vol) => vol.coinTypeIn),
-                    ...volumes.map((vol) => vol.coinTypeOut),
-                ]);
-                const [coinsToPrice, coinsToDecimals] = yield Promise.all([
-                    this.Provider.Prices().fetchCoinsToPrice({ coins }),
-                    this.Provider.Coin().fetchCoinsToDecimals({ coins }),
-                ]);
-                return utils_2.Helpers.calcIndexerVolumeUsd({
-                    volumes,
-                    coinsToPrice,
-                    coinsToDecimals,
-                });
-            }),
-        });
-        /**
-         * Calculates the pool supply per LP token.
-         * @param poolCoins - The pool coins object.
-         * @param lpSupply - The total supply of LP tokens.
-         * @returns An array of supply per LP token for each pool coin.
-         */
-        this.calcPoolSupplyPerLps = (poolCoins, lpSupply) => {
-            const supplyPerLps = Object.values(poolCoins).map((poolCoin) => Number(poolCoin.balance) / Number(lpSupply));
-            return supplyPerLps;
-        };
-        /**
-         * Calculates the price of a liquidity pool token.
-         * @param inputs - An object containing the liquidity pool token supply, total value locked, and the number of decimal places for the token.
-         * @returns The price of the liquidity pool token.
-         */
-        this.calcPoolLpPrice = (inputs) => {
-            const { lpCoinSupply, tvl, lpCoinDecimals } = inputs;
-            const lpPrice = Number(Number(tvl) / coin_1.Coin.balanceWithDecimals(lpCoinSupply, lpCoinDecimals));
-            return lpPrice;
-        };
-        /**
-         * Calculates the APR (Annual Percentage Rate) based on the fees collected in the last 24 hours and the TVL (Total Value Locked) of a pool.
-         * @param inputs - An object containing the fees collected in the last 24 hours and the TVL of a pool.
-         * @returns The APR (Annual Percentage Rate) of the pool.
-         */
-        this.calcApr = (inputs) => {
-            const { fees24Hours, tvl } = inputs;
-            // TODO: use daysjs instead
-            const daysInYear = 365;
-            return (fees24Hours * daysInYear) / tvl;
-        };
-        // =========================================================================
-        //  Prices
-        // =========================================================================
-        // TODO: make this faster this is slow as shit when LP balances are involved...
-        // (so much fetching!)
-        // TODO: rename this function and/or move it ?
-        /**
-         * Fetches the prices of the given LP coins.
-         * @param lpCoins The LP coins to fetch prices for.
-         * @returns An object containing the prices of the LP coins.
-         */
-        this.fetchLpCoinsToPrice = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            const { lpCoins } = inputs;
-            const unsafeLpCoinPoolObjectIds = yield Promise.all(lpCoins.map((lpCoinType) => __awaiter(this, void 0, void 0, function* () {
-                return this.fetchPoolObjectIdForLpCoinType({
-                    lpCoinType,
-                });
-            })));
-            const safeIndexes = [];
-            const lpCoinPoolObjectIds = unsafeLpCoinPoolObjectIds.filter((id, index) => {
-                const isValid = id !== undefined;
-                if (isValid)
-                    safeIndexes.push(index);
-                return isValid;
-            });
-            const poolStats = yield Promise.all(lpCoinPoolObjectIds.map((poolId) => this.fetchPoolStats({ poolId })));
-            let lpCoinsToPrice = {};
-            for (const [index, safeIndex] of safeIndexes.entries()) {
-                const lpCoin = lpCoins[safeIndex];
-                const coinPrice = poolStats[index].lpPrice;
-                lpCoinsToPrice = Object.assign(Object.assign({}, lpCoinsToPrice), { [lpCoin]: coinPrice });
-            }
-            for (const [index, lpCoin] of lpCoins.entries()) {
-                if (safeIndexes.includes(index))
-                    continue;
-                lpCoinsToPrice = Object.assign(Object.assign({}, lpCoinsToPrice), { [lpCoin]: -1 });
-            }
-            return lpCoinsToPrice;
-        });
-        // =========================================================================
-        //  Graph Data
-        // =========================================================================
-        /**
-         * Calculates the pool fee data from the given volume data and pool trade fee.
-         * @param inputs - The inputs required to calculate the pool fee data.
-         * @param inputs.volumeData - The volume data to calculate the pool fee data from.
-         * @param inputs.poolTradeFee - The pool trade fee to use for the calculation.
-         * @returns The pool fee data calculated from the given volume data and pool trade fee.
-         */
-        this.calcPoolFeeDataFromVolume = (inputs) => {
-            const feeData = inputs.volumeData.map((data) => ({
-                time: data.time,
-                value: data.value * fixedUtils_1.FixedUtils.directCast(inputs.poolTradeFee),
-            }));
-            return feeData;
-        };
-        /**
-         * Calculates the pool volume data based on the provided inputs.
-         * @param inputs An object containing the necessary inputs for the calculation.
-         * @param inputs.tradeEvents An array of pool trade events.
-         * @param inputs.timeUnit The time unit to use for the calculation.
-         * @param inputs.time The time duration to use for the calculation.
-         * @returns An array of pool data points.
-         */
-        this.fetchCalcPoolVolumeData = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            const { poolId, timeframe } = inputs;
-            const pool = yield this.fetchPool({ objectId: poolId });
-            const coins = Object.keys(pool.coins);
-            const [coinsToPrice, coinsToDecimals] = yield Promise.all([
-                this.Provider.Prices().fetchCoinsToPrice({
-                    coins,
-                }),
-                this.Provider.Coin().fetchCoinsToDecimals({ coins }),
-            ]);
-            const { time, timeUnit } = PoolsApi.poolVolumeDataTimeframes[timeframe];
-            const tradeEvents = yield this.fetchTradeEventsWithinTime({
-                time,
-                timeUnit,
-                poolId,
-            });
-            const buckets = time;
-            const now = Date.now();
-            const maxTimeAgo = (0, dayjs_1.default)(now).subtract(time, timeUnit);
-            const timeGap = (0, dayjs_1.default)(now).diff(maxTimeAgo);
-            const bucketTimestampSize = timeGap / buckets;
-            const emptyDataPoints = Array(buckets)
-                .fill({
-                time: 0,
-                value: 0,
-            })
-                .map((dataPoint, index) => {
-                return Object.assign(Object.assign({}, dataPoint), { time: maxTimeAgo.valueOf() + index * bucketTimestampSize });
-            });
-            const dataPoints = tradeEvents.reduce((acc, trade) => {
-                if (trade.timestamp === undefined)
-                    return acc;
-                const tradeDate = dayjs_1.default.unix(trade.timestamp / 1000);
-                const bucketIndex = acc.length -
-                    Math.floor((0, dayjs_1.default)(now).diff(tradeDate) / bucketTimestampSize) -
-                    1;
-                const amountUsd = trade.typesIn.reduce((acc, cur, index) => {
-                    const price = coinsToPrice[cur];
-                    const amountInUsd = price < 0
-                        ? 0
-                        : coin_1.Coin.balanceWithDecimalsUsd(trade.amountsIn[index], coinsToDecimals[cur], price);
-                    return acc + (amountInUsd < 0 ? 0 : amountInUsd);
-                }, 0);
-                acc[bucketIndex].value += amountUsd;
-                return acc;
-            }, emptyDataPoints);
-            return dataPoints;
-        });
-        // =========================================================================
-        //  LP Coin Metadata
-        // =========================================================================
-        /**
-         * Creates a description for the Aftermath LP coin for a given pool.
-         * @param inputs - An object containing the pool name and an array of coin types.
-         * @returns A string describing the Aftermath LP coin for the given pool.
-         */
-        this.createLpCoinMetadataDescription = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            // TODO: do all of this a little bit cleaner
-            // TODO: should metadata be passed into pool creation func ?
-            const coinSymbols = (yield Promise.all(inputs.coinTypes.map((coin) => this.Provider.Coin().fetchCoinMetadata({ coin })))).map((metadata) => metadata.symbol);
-            return `Aftermath LP coin for ${inputs.poolName} Pool (${coinSymbols.reduce((acc, symbol, index) => acc + symbol + (index >= coinSymbols.length - 1 ? "" : ", "), "")})`;
-        });
-        // =========================================================================
-        //  CoinGecko Integration
-        // =========================================================================
-        this.fetchCoinGeckoTickerData = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            const { pools, coinsToDecimals } = inputs;
-            return (yield Promise.all(pools.map((pool) => __awaiter(this, void 0, void 0, function* () {
-                const durationMs24hrs = 86400000;
-                const volumes = yield this.fetchPoolVolume({
-                    poolId: pool.pool.objectId,
-                    durationMs: durationMs24hrs,
-                });
-                return Object.keys(pool.pool.coins)
-                    .slice(0, -1)
-                    .map((baseCoinType, index) => {
-                    return Object.keys(pool.pool.coins)
-                        .slice(index + 1)
-                        .map((targetCoinType) => {
-                        if (!pool.stats)
-                            throw new Error("pool is missing stats");
-                        if (baseCoinType === targetCoinType)
-                            return undefined;
-                        const volumeData = (() => {
-                            var _a, _b;
-                            const volumeDataIn = (_a = volumes.find((volume) => volume.coinTypeIn ===
-                                baseCoinType)) !== null && _a !== void 0 ? _a : {
-                                totalAmountIn: 0,
-                                totalAmountOut: 0,
-                            };
-                            const volumeDataOut = (_b = volumes.find((volume) => volume.coinTypeOut ===
-                                baseCoinType)) !== null && _b !== void 0 ? _b : {
-                                totalAmountIn: 0,
-                                totalAmountOut: 0,
-                            };
-                            return {
-                                baseVolume: volumeDataIn.totalAmountIn +
-                                    volumeDataOut.totalAmountOut,
-                                targetVolume: volumeDataIn.totalAmountOut +
-                                    volumeDataOut.totalAmountIn,
-                            };
-                        })();
-                        const baseDecimals = coinsToDecimals[baseCoinType];
-                        const targetDecimals = coinsToDecimals[targetCoinType];
-                        if (baseDecimals === undefined ||
-                            targetDecimals === undefined)
-                            throw new Error("coin decimals not found");
-                        const baseVolume = coin_1.Coin.balanceWithDecimals(BigInt(volumeData.baseVolume), baseDecimals);
-                        const targetVolume = coin_1.Coin.balanceWithDecimals(BigInt(volumeData.targetVolume), targetDecimals);
-                        const unscaledPrice = pool.getSpotPrice({
-                            coinInType: baseCoinType,
-                            coinOutType: targetCoinType,
-                        });
-                        const denominator = coin_1.Coin.balanceWithDecimals(unscaledPrice, baseDecimals - targetDecimals);
-                        const price = denominator
-                            ? 1 / denominator
-                            : 0;
-                        const data = {
-                            pool_id: pool.pool.objectId,
-                            base_currency: baseCoinType,
-                            target_currency: targetCoinType,
-                            ticker_id: `${baseCoinType}_${targetCoinType}`,
-                            liquidity_in_usd: pool.stats.tvl,
-                            base_volume: baseVolume,
-                            target_volume: targetVolume,
-                            last_price: price,
-                        };
-                        return data;
-                    })
-                        .reduce((prev, curr) => [
-                        ...prev,
-                        ...(curr ? [curr] : []),
-                    ], []);
-                })
-                    .reduce((prev, curr) => [...prev, ...curr], []);
-            })))).reduce((prev, curr) => [...prev, ...curr], []);
-        });
-        // public fetchCoinGeckoHistoricalTradeData = async (inputs: {
-        // 	limit: number;
-        // 	baseCoinType: CoinType;
-        // 	targetCoinType: CoinType;
-        // 	coinsToDecimals: CoinsToDecimals;
-        // }): Promise<CoinGeckoHistoricalTradeData[]> => {
-        // 	const { coinsToDecimals } = inputs;
-        // 	const trades = await this.fetchCoinGeckoHistoricalTrades(inputs);
-        // 	return trades.map((trade) => {
-        // 		const amountInWithDecimals = Coin.balanceWithDecimals(
-        // 			BigInt(trade.amountIn),
-        // 			coinsToDecimals[trade.coinTypeIn]
-        // 		);
-        // 		const amountOutWithDecimals = Coin.balanceWithDecimals(
-        // 			BigInt(trade.amountOut),
-        // 			coinsToDecimals[trade.coinTypeOut]
-        // 		);
-        // 		const [baseAmount, targetAmount, type]: [
-        // 			number,
-        // 			number,
-        // 			"buy" | "sell"
-        // 		] =
-        // 			trade.coinTypeIn === inputs.baseCoinType
-        // 				? [amountInWithDecimals, amountOutWithDecimals, "sell"]
-        // 				: [amountOutWithDecimals, amountInWithDecimals, "buy"];
-        // 		const price = baseAmount / targetAmount;
-        // 		return {
-        // 			price,
-        // 			type,
-        // 			trade_id: trade._id.$oid,
-        // 			base_volume: baseAmount,
-        // 			target_volume: targetAmount,
-        // 			trade_timestamp: trade.timestampMs,
-        // 		};
-        // 	});
-        // };
-        // =========================================================================
-        //  Private Methods
-        // =========================================================================
-        // =========================================================================
-        //  Helpers
-        // =========================================================================
-        // private async fetchCoinGeckoHistoricalTrades(inputs: {
-        // 	limit: number;
-        // 	baseCoinType: CoinType;
-        // 	targetCoinType: CoinType;
-        // }): Promise<
-        // 	{
-        // 		_id: {
-        // 			$oid: UniqueId;
-        // 		};
-        // 		amountIn: number;
-        // 		amountOut: number;
-        // 		timestampMs: Timestamp;
-        // 		coinTypeIn: CoinType;
-        // 		coinTypeOut: CoinType;
-        // 	}[]
-        // > {
-        // 	const { limit, baseCoinType, targetCoinType } = inputs;
-        // 	return this.Provider.indexerCaller.fetchIndexer(
-        // 		`pools/coingecko/historical-trades/${Helpers.addLeadingZeroesToType(
-        // 			baseCoinType
-        // 		)}/${Helpers.addLeadingZeroesToType(targetCoinType)}`,
-        // 		{
-        // 			limit,
-        // 		}
-        // 	);
-        // }
-        // =========================================================================
         //  Event Types
         // =========================================================================
         this.tradeEventType = () => eventsApiHelpers_1.EventsApiHelpers.createEventType(this.addresses.pools.packages.events, PoolsApi.constants.moduleNames.events, PoolsApi.constants.eventNames.swap);
@@ -1482,79 +821,6 @@ class PoolsApi {
             }
             : {}));
     }
-    // =========================================================================
-    //  Events
-    // =========================================================================
-    /**
-     * Fetches trade events for a pool.
-     * @async
-     * @param {ApiIndexerEventsBody & { poolId: ObjectId }} inputs - An object containing the pool ID, cursor, and limit.
-     * @returns {Promise<PoolTradeEvent[]>} A promise that resolves to an array of fetched trade events.
-     */
-    fetchTradeEvents(inputs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { poolId, cursor, limit } = inputs;
-            return this.Provider.indexerCaller.fetchIndexerEvents(`pools/${poolId}/events/swap`, {
-                cursor,
-                limit,
-            }, casting_1.Casting.pools.poolTradeEventFromIndexerOnChain);
-        });
-    }
-    /**
-     * Fetches withdraw events for a pool.
-     * @async
-     * @param {ApiIndexerEventsBody & { poolId: ObjectId }} inputs - An object containing the pool ID, cursor, and limit.
-     * @returns {Promise<PoolWithdrawEvent[]>} A promise that resolves to an array of fetched withdraw events.
-     */
-    fetchWithdrawEvents(inputs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { poolId, cursor, limit } = inputs;
-            return this.Provider.indexerCaller.fetchIndexerEvents(`pools/${poolId}/events/withdraw`, {
-                cursor,
-                limit,
-            }, casting_1.Casting.pools.poolWithdrawEventFromIndexerOnChain);
-        });
-    }
-    /**
-     * Fetches deposit events for a pool.
-     * @async
-     * @param {ApiIndexerEventsBody & { poolId: ObjectId }} inputs - An object containing the pool ID, cursor, and limit.
-     * @returns {Promise<PoolDepositEvent[]>} A promise that resolves to an array of fetched deposit events.
-     */
-    fetchDepositEvents(inputs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { poolId, cursor, limit } = inputs;
-            return this.Provider.indexerCaller.fetchIndexerEvents(`pools/${poolId}/events/deposit`, {
-                cursor,
-                limit,
-            }, casting_1.Casting.pools.poolDepositEventFromIndexerOnChain);
-        });
-    }
-    /**
-     * Fetches trade events for a pool within a specified time frame.
-     * @async
-     * @param {ObjectId} inputs.poolId - The object ID of the pool to fetch trade events for.
-     * @param {DurationUnitType} inputs.timeUnit - The time unit of the time frame.
-     * @param {number} inputs.time - The duration of the time frame.
-     * @returns {Promise<PoolTradeEvent[]>} A promise that resolves to an array of fetched trade events.
-     */
-    fetchTradeEventsWithinTime(inputs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const { poolId, timeUnit, time } = inputs;
-                dayjs_1.default.extend(duration_1.default);
-                const durationMs = dayjs_1.default.duration(time, timeUnit).asMilliseconds();
-                const tradeEventsOnChain = yield this.Provider.indexerCaller.fetchIndexer(`pools/${poolId}/swap-events-within-time/${durationMs}`, undefined, {
-                    skip: 0,
-                    limit: 10000, // max from mongo ?
-                });
-                return tradeEventsOnChain.map(casting_1.Casting.pools.poolTradeEventFromIndexerOnChain);
-            }
-            catch (e) {
-                return [];
-            }
-        });
-    }
 }
 exports.PoolsApi = PoolsApi;
 // =========================================================================
@@ -1589,21 +855,3 @@ PoolsApi.constants = {
     },
     defaultLpCoinIconImageUrl: "https://aftermath.finance/coins/lp/af_lp.svg",
 };
-PoolsApi.poolVolumeDataTimeframes = {
-    "1D": {
-        time: 24,
-        timeUnit: "hour",
-    },
-    // "1W": {
-    // 	time: 7,
-    // 	timeUnit: "day",
-    // },
-    // "1M": {
-    // 	time: 30,
-    // 	timeUnit: "day",
-    // },
-    // "3M": {
-    // 	time: 90,
-    // 	timeUnit: "day",
-    // },
-};