aftermath-ts-sdk 0.0.162 → 0.0.164

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

@@ -8,121 +8,131 @@ 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 poolsApiHelpers_1 = require("./poolsApiHelpers");
+const sui_js_1 = require("@mysten/sui.js");
 const casting_1 = require("../../../general/utils/casting");
 const __1 = require("..");
 const utils_1 = require("../../../general/utils");
+const coin_1 = require("../../coin");
+const dayjs_1 = __importDefault(require("dayjs"));
+const poolsApiCasting_1 = require("./poolsApiCasting");
+const eventsApiHelpers_1 = require("../../../general/api/eventsApiHelpers");
 class PoolsApi {
-    /////////////////////////////////////////////////////////////////////
-    //// Constructor
-    /////////////////////////////////////////////////////////////////////
+    // =========================================================================
+    //  Constructor
+    // =========================================================================
     constructor(Provider) {
+        var _a;
         this.Provider = Provider;
-        /////////////////////////////////////////////////////////////////////
-        //// Public Methods
-        /////////////////////////////////////////////////////////////////////
-        /////////////////////////////////////////////////////////////////////
-        //// Events
-        /////////////////////////////////////////////////////////////////////
-        this.fetchTradeEvents = (cursor, limit
-        // poolObjectId?: ObjectId
-        ) => __awaiter(this, void 0, void 0, function* () {
-            return yield this.Provider.Events().fetchCastEventsWithCursor(
-            // poolObjectId
-            // 	? {
-            // 			And: [
-            // 				{ MoveEventType: this.Helpers.eventTypes.trade },
-            // 				{
-            // 					MoveEventField: {
-            // 						path: "pool_id",
-            // 						value: poolObjectId,
-            // 					},
-            // 				},
-            // 			],
-            // 	  }
-            // 	: { MoveEventType: this.Helpers.eventTypes.trade },
-            { MoveEventType: this.Helpers.eventTypes.trade }, casting_1.Casting.pools.poolTradeEventFromOnChain, cursor, limit);
-        });
-        this.fetchDepositEvents = (cursor, limit
-        // poolObjectId?: ObjectId
-        ) => __awaiter(this, void 0, void 0, function* () {
-            return yield this.Provider.Events().fetchCastEventsWithCursor(
-            // poolObjectId
-            // 	? {
-            // 			And: [
-            // 				{ MoveEventType: this.Helpers.eventTypes.deposit },
-            // 				{
-            // 					MoveEventField: {
-            // 						path: "pool_id",
-            // 						value: poolObjectId,
-            // 					},
-            // 				},
-            // 			],
-            // 	  }
-            // 	: { MoveEventType: this.Helpers.eventTypes.deposit },
-            { MoveEventType: this.Helpers.eventTypes.deposit }, casting_1.Casting.pools.poolDepositEventFromOnChain, cursor, limit);
-        });
-        this.fetchWithdrawEvents = (cursor, limit
-        // poolObjectId?: ObjectId
-        ) => __awaiter(this, void 0, void 0, function* () {
-            return yield this.Provider.Events().fetchCastEventsWithCursor(
-            // poolObjectId
-            // 	? {
-            // 			And: [
-            // 				{ MoveEventType: this.Helpers.eventTypes.withdraw },
-            // 				{
-            // 					MoveEventField: {
-            // 						path: "pool_id",
-            // 						value: poolObjectId,
-            // 					},
-            // 				},
-            // 			],
-            // 	  }
-            // 	: { MoveEventType: this.Helpers.eventTypes.withdraw },
-            { MoveEventType: this.Helpers.eventTypes.withdraw }, casting_1.Casting.pools.poolWithdrawEventFromOnChain, cursor, limit);
-        });
-        /////////////////////////////////////////////////////////////////////
-        //// Objects
-        /////////////////////////////////////////////////////////////////////
-        this.fetchPool = (objectId) => __awaiter(this, void 0, void 0, function* () {
-            return this.Provider.Objects().fetchCastObject(objectId, casting_1.Casting.pools.poolObjectFromSuiObject);
-        });
-        this.fetchPools = (objectIds) => __awaiter(this, void 0, void 0, function* () {
-            return this.Provider.Objects().fetchCastObjectBatch(objectIds, casting_1.Casting.pools.poolObjectFromSuiObject);
+        this.poolVolumeDataTimeframes = {
+            "1D": {
+                time: 24,
+                timeUnit: "hour",
+            },
+            "1W": {
+                time: 7,
+                timeUnit: "day",
+            },
+            "1M": {
+                time: 30,
+                timeUnit: "day",
+            },
+            "3M": {
+                time: 90,
+                timeUnit: "day",
+            },
+        };
+        // =========================================================================
+        //  Public Methods
+        // =========================================================================
+        // =========================================================================
+        //  Events
+        // =========================================================================
+        this.fetchTradeEvents = (inputs) => __awaiter(this, void 0, void 0, function* () {
+            return yield this.Provider.Events().fetchCastEventsWithCursor(Object.assign(Object.assign({}, inputs), { 
+                // poolObjectId
+                // 	? {
+                // 			And: [
+                // 				{ MoveEventType: this.eventTypes.trade },
+                // 				{
+                // 					MoveEventField: {
+                // 						path: "pool_id",
+                // 						value: poolObjectId,
+                // 					},
+                // 				},
+                // 			],
+                // 	  }
+                // 	: { MoveEventType: this.eventTypes.trade },
+                query: { MoveEventType: this.eventTypes.trade }, eventFromEventOnChain: casting_1.Casting.pools.poolTradeEventFromOnChain }));
         });
-        this.fetchAllPools = () => __awaiter(this, void 0, void 0, function* () {
-            const poolObjectIds = yield this.Helpers.fetchAllPoolObjectIds();
-            return this.fetchPools(poolObjectIds);
+        this.fetchDepositEvents = (inputs) => __awaiter(this, void 0, void 0, function* () {
+            return yield this.Provider.Events().fetchCastEventsWithCursor(Object.assign(Object.assign({}, inputs), { 
+                // query: inputs.poolObjectId
+                // 	? {
+                // 			And: [
+                // 				{ MoveEventType: this.eventTypes.deposit },
+                // 				{
+                // 					MoveEventField: {
+                // 						path: "pool_id",
+                // 						value: inputs.poolObjectId,
+                // 					},
+                // 				},
+                // 			],
+                // 	  }
+                // 	: { MoveEventType: this.eventTypes.deposit },
+                query: { MoveEventType: this.eventTypes.deposit }, eventFromEventOnChain: casting_1.Casting.pools.poolDepositEventFromOnChain }));
         });
-        /////////////////////////////////////////////////////////////////////
-        //// Transactions
-        /////////////////////////////////////////////////////////////////////
-        this.fetchDepositTransaction = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            const transaction = yield this.Helpers.fetchBuildDepositTx(inputs);
-            return this.Provider.Transactions().fetchSetGasBudgetAndSerializeTransaction(transaction);
+        this.fetchWithdrawEvents = (inputs) => __awaiter(this, void 0, void 0, function* () {
+            return yield this.Provider.Events().fetchCastEventsWithCursor(Object.assign(Object.assign({}, inputs), { 
+                // poolObjectId
+                // 	? {
+                // 			And: [
+                // 				{ MoveEventType: this.eventTypes.withdraw },
+                // 				{
+                // 					MoveEventField: {
+                // 						path: "pool_id",
+                // 						value: poolObjectId,
+                // 					},
+                // 				},
+                // 			],
+                // 	  }
+                // 	: { MoveEventType: this.eventTypes.withdraw },
+                query: { MoveEventType: this.eventTypes.withdraw }, eventFromEventOnChain: casting_1.Casting.pools.poolWithdrawEventFromOnChain }));
         });
-        this.fetchWithdrawTransaction = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            const transaction = yield this.Helpers.fetchBuildWithdrawTx(inputs);
-            return this.Provider.Transactions().fetchSetGasBudgetAndSerializeTransaction(transaction);
+        // =========================================================================
+        //  Objects
+        // =========================================================================
+        this.fetchPool = (inputs) => __awaiter(this, void 0, void 0, function* () {
+            return this.Provider.Objects().fetchCastObject(Object.assign(Object.assign({}, inputs), { objectFromSuiObjectResponse: casting_1.Casting.pools.poolObjectFromSuiObject }));
         });
-        this.fetchAllCoinWithdrawTransaction = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            const transaction = yield this.Helpers.fetchBuildAllCoinWithdrawTx(inputs);
-            return this.Provider.Transactions().fetchSetGasBudgetAndSerializeTransaction(transaction);
+        this.fetchPools = (inputs) => __awaiter(this, void 0, void 0, function* () {
+            return this.Provider.Objects().fetchCastObjectBatch(Object.assign(Object.assign({}, inputs), { objectFromSuiObjectResponse: casting_1.Casting.pools.poolObjectFromSuiObject }));
         });
-        this.fetchTradeTransaction = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            const transaction = yield this.Helpers.fetchBuildTradeTx(inputs);
-            return this.Provider.Transactions().fetchSetGasBudgetAndSerializeTransaction(transaction);
+        this.fetchAllPools = () => __awaiter(this, void 0, void 0, function* () {
+            const objectIds = yield this.fetchAllPoolObjectIds();
+            return this.fetchPools({ objectIds });
         });
-        this.publishLpCoinTransaction = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            return this.Provider.Transactions().fetchSetGasBudgetAndSerializeTransaction(this.Helpers.buildPublishLpCoinTx(inputs));
+        this.fetchAllPoolObjectIds = () => __awaiter(this, void 0, void 0, function* () {
+            const objectIds = yield this.Provider.DynamicFields().fetchCastAllDynamicFieldsOfType({
+                parentObjectId: this.addresses.pools.objects.lpCoinsTable,
+                objectsFromObjectIds: (objectIds) => this.Provider.Objects().fetchCastObjectBatch({
+                    objectIds,
+                    objectFromSuiObjectResponse: poolsApiCasting_1.PoolsApiCasting.poolObjectIdFromSuiObjectResponse,
+                }),
+            });
+            const filteredIds = objectIds.filter((id) => !PoolsApi.constants.blacklistedPoolIds.includes(id));
+            return filteredIds;
         });
-        this.fetchCreatePoolTransaction = (inputs) => __awaiter(this, void 0, void 0, function* () {
+        // =========================================================================
+        //  Transaction Builders
+        // =========================================================================
+        this.fetchCreatePoolTx = (inputs) => __awaiter(this, void 0, void 0, function* () {
             // NOTE: these are temp defaults down below since some selections are currently disabled in contracts
-            return this.Provider.Transactions().fetchSetGasBudgetAndSerializeTransaction(this.Helpers.fetchBuildCreatePoolTx(Object.assign(Object.assign({}, inputs), { poolFlatness: inputs.poolFlatness === 1
-                    ? casting_1.Casting.fixedOneBigInt
-                    : BigInt(0), coinsInfo: inputs.coinsInfo.map((info, index) => {
+            return this.fetchBuildCreatePoolTx(Object.assign(Object.assign({}, inputs), { lpCoinIconUrl: "", poolFlatness: inputs.poolFlatness === 1 ? casting_1.Casting.fixedOneBigInt : BigInt(0), coinsInfo: inputs.coinsInfo.map((info, index) => {
                     let weight = casting_1.Casting.numberToFixedBigInt(info.weight);
                     if (index === 0) {
                         const otherWeightsSum = utils_1.Helpers.sumBigInt(inputs.coinsInfo
@@ -131,13 +141,355 @@ class PoolsApi {
                         weight = casting_1.Casting.fixedOneBigInt - otherWeightsSum;
                     }
                     return Object.assign(Object.assign({}, info), { weight, tradeFeeIn: casting_1.Casting.numberToFixedBigInt(info.tradeFeeIn), depositFee: BigInt(0), withdrawFee: BigInt(0), tradeFeeOut: BigInt(0) });
-                }) })));
+                }) }));
         });
-        /////////////////////////////////////////////////////////////////////
-        //// Inspections
-        /////////////////////////////////////////////////////////////////////
-        this.fetchPoolObjectIdForLpCoinType = (lpCoinType) => __awaiter(this, void 0, void 0, function* () {
-            const tx = this.Helpers.poolObjectIdForLpCoinTypeDevInspectTransaction(lpCoinType);
+        this.fetchBuildTradeTx = (inputs) => __awaiter(this, void 0, void 0, function* () {
+            const { walletAddress, pool, coinInAmount, coinInType, coinOutType, slippage, referrer, } = inputs;
+            const tx = new sui_js_1.TransactionBlock();
+            tx.setSender(walletAddress);
+            if (referrer)
+                this.Provider.ReferralVault().updateReferrerTx({
+                    tx,
+                    referrer,
+                });
+            const amountOut = pool.getTradeAmountOut({
+                coinInAmount,
+                coinInType,
+                coinOutType,
+                referral: referrer !== undefined,
+            });
+            const coinInId = yield this.Provider.Coin().fetchCoinWithAmountTx({
+                tx,
+                walletAddress,
+                coinType: coinInType,
+                coinAmount: coinInAmount,
+            });
+            this.tradeTx({
+                tx,
+                coinInId,
+                poolId: pool.pool.objectId,
+                expectedCoinOutAmount: amountOut,
+                lpCoinType: pool.pool.lpCoinType,
+                coinInType,
+                coinOutType,
+                slippage,
+                withTransfer: true,
+            });
+            return tx;
+        });
+        this.fetchBuildDepositTx = (inputs) => __awaiter(this, void 0, void 0, function* () {
+            const { walletAddress, pool, amountsIn, slippage, referrer } = inputs;
+            const tx = new sui_js_1.TransactionBlock();
+            tx.setSender(walletAddress);
+            if (referrer)
+                this.Provider.ReferralVault().updateReferrerTx({
+                    tx,
+                    referrer,
+                });
+            const { coins: coinTypes, balances: coinAmounts } = coin_1.Coin.coinsAndBalancesOverZero(amountsIn);
+            const { lpRatio } = pool.getDepositLpAmountOut({
+                amountsIn,
+                referral: referrer !== undefined,
+            });
+            // TODO: move this somewhere else and into its own func
+            const expectedLpRatio = casting_1.Casting.numberToFixedBigInt(lpRatio);
+            const coinIds = yield this.Provider.Coin().fetchCoinsWithAmountTx(Object.assign(Object.assign({}, inputs), { tx,
+                coinTypes,
+                coinAmounts }));
+            this.multiCoinDepositTx({
+                tx,
+                poolId: pool.pool.objectId,
+                lpCoinType: pool.pool.lpCoinType,
+                coinIds,
+                coinTypes,
+                expectedLpRatio,
+                slippage,
+                withTransfer: true,
+            });
+            return tx;
+        });
+        this.fetchBuildWithdrawTx = (inputs) => __awaiter(this, void 0, void 0, function* () {
+            const { walletAddress, pool, amountsOutDirection, lpCoinAmount, slippage, referrer, } = inputs;
+            const tx = new sui_js_1.TransactionBlock();
+            tx.setSender(walletAddress);
+            if (referrer)
+                this.Provider.ReferralVault().updateReferrerTx({
+                    tx,
+                    referrer,
+                });
+            const lpRatio = pool.getMultiCoinWithdrawLpRatio({
+                lpCoinAmountOut: lpCoinAmount,
+            });
+            const amountsOut = pool.getWithdrawAmountsOut({
+                lpRatio,
+                amountsOutDirection,
+                referral: referrer !== undefined,
+            });
+            const { coins: coinTypes, balances: coinAmounts } = coin_1.Coin.coinsAndBalancesOverZero(amountsOut);
+            const lpCoinId = yield this.Provider.Coin().fetchCoinWithAmountTx({
+                tx,
+                walletAddress,
+                coinType: pool.pool.lpCoinType,
+                coinAmount: lpCoinAmount,
+            });
+            this.multiCoinWithdrawTx({
+                tx,
+                poolId: pool.pool.objectId,
+                lpCoinType: pool.pool.lpCoinType,
+                expectedAmountsOut: coinAmounts,
+                coinTypes: coinTypes,
+                lpCoinId,
+                slippage,
+                withTransfer: true,
+            });
+            return tx;
+        });
+        this.fetchBuildAllCoinWithdrawTx = (inputs) => __awaiter(this, void 0, void 0, function* () {
+            const { walletAddress, pool, lpCoinAmount, referrer } = inputs;
+            const tx = new sui_js_1.TransactionBlock();
+            tx.setSender(walletAddress);
+            if (referrer)
+                this.Provider.ReferralVault().updateReferrerTx({
+                    tx,
+                    referrer,
+                });
+            const lpCoinId = yield this.Provider.Coin().fetchCoinWithAmountTx({
+                tx,
+                walletAddress,
+                coinType: pool.pool.lpCoinType,
+                coinAmount: lpCoinAmount,
+            });
+            const coinTypes = Object.keys(pool.pool.coins);
+            this.allCoinWithdrawTx({
+                tx,
+                poolId: pool.pool.objectId,
+                lpCoinType: pool.pool.lpCoinType,
+                coinTypes,
+                lpCoinId,
+                withTransfer: true,
+            });
+            return tx;
+        });
+        this.buildPublishLpCoinTx = (inputs) => {
+            const tx = new sui_js_1.TransactionBlock();
+            tx.setSender(inputs.walletAddress);
+            const upgradeCap = this.publishLpCoinTx({ tx });
+            tx.transferObjects([upgradeCap], tx.pure(inputs.walletAddress));
+            return tx;
+        };
+        this.fetchBuildCreatePoolTx = (inputs) => __awaiter(this, void 0, void 0, function* () {
+            const { coinsInfo } = inputs;
+            const tx = new sui_js_1.TransactionBlock();
+            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) }));
+            yield this.createPoolTx(Object.assign(Object.assign({ tx }, inputs), { 
+                // createPoolCapId,
+                coinsInfo: coinsInfo.map((info, index) => {
+                    return Object.assign(Object.assign({}, info), { coinId: coinArgs[index] });
+                }), lpCoinDescription }));
+            return tx;
+        });
+        // =========================================================================
+        //  Transaction Commands
+        // =========================================================================
+        this.tradeTx = (inputs) => {
+            const { tx, poolId, coinInId, coinInType, expectedCoinOutAmount, coinOutType, lpCoinType, slippage, withTransfer, } = inputs;
+            return tx.add({
+                kind: "MoveCall",
+                target: utils_1.Helpers.transactions.createTxTarget(withTransfer
+                    ? this.addresses.pools.packages.ammInterface
+                    : this.addresses.pools.packages.amm, withTransfer
+                    ? PoolsApi.constants.moduleNames.interface
+                    : PoolsApi.constants.moduleNames.swap, "swap_exact_in"),
+                typeArguments: [lpCoinType, coinInType, coinOutType],
+                arguments: [
+                    tx.object(poolId),
+                    tx.object(this.addresses.pools.objects.poolRegistry),
+                    tx.object(this.addresses.pools.objects.protocolFeeVault),
+                    tx.object(this.addresses.pools.objects.treasury),
+                    tx.object(this.addresses.pools.objects.insuranceFund),
+                    tx.object(this.addresses.referralVault.objects.referralVault),
+                    typeof coinInId === "string" ? tx.object(coinInId) : coinInId,
+                    tx.pure(expectedCoinOutAmount.toString()),
+                    tx.pure(__1.Pools.normalizeSlippage(slippage)),
+                ],
+            });
+        };
+        this.routerWrapperTradeTx = (inputs) => {
+            var _a;
+            const wrapperAddress = (_a = this.addresses.routerWrapper) === null || _a === void 0 ? void 0 : _a.packages.wrapper;
+            if (!wrapperAddress)
+                throw new Error("Aftermath router wrapper address not set");
+            const { tx, poolId, coinInId, coinInType, expectedCoinOutAmount, coinOutType, lpCoinType, slippage, tradePotato, isFirstSwapForPath, isLastSwapForPath, } = inputs;
+            return tx.moveCall({
+                target: utils_1.Helpers.transactions.createTxTarget(wrapperAddress, PoolsApi.constants.moduleNames.routerWrapper, "swap_exact_in"),
+                typeArguments: [lpCoinType, coinInType, coinOutType],
+                arguments: [
+                    tx.object(poolId),
+                    tx.object(this.addresses.pools.objects.poolRegistry),
+                    typeof coinInId === "string" ? tx.object(coinInId) : coinInId,
+                    tx.pure(expectedCoinOutAmount.toString()),
+                    tx.pure(__1.Pools.normalizeSlippage(slippage)),
+                    // AF fees
+                    tx.object(this.addresses.pools.objects.protocolFeeVault),
+                    tx.object(this.addresses.pools.objects.treasury),
+                    tx.object(this.addresses.pools.objects.insuranceFund),
+                    tx.object(this.addresses.referralVault.objects.referralVault),
+                    // router
+                    tradePotato,
+                    tx.pure(isFirstSwapForPath, "bool"),
+                    tx.pure(isLastSwapForPath, "bool"),
+                ],
+            });
+        };
+        this.multiCoinDepositTx = (inputs) => {
+            const { tx, poolId, coinIds, coinTypes, expectedLpRatio, lpCoinType, slippage, withTransfer, } = inputs;
+            const poolSize = coinTypes.length;
+            return tx.add({
+                kind: "MoveCall",
+                target: utils_1.Helpers.transactions.createTxTarget(withTransfer
+                    ? this.addresses.pools.packages.ammInterface
+                    : this.addresses.pools.packages.amm, withTransfer
+                    ? PoolsApi.constants.moduleNames.interface
+                    : PoolsApi.constants.moduleNames.deposit, `deposit_${poolSize}_coins`),
+                typeArguments: [lpCoinType, ...coinTypes],
+                arguments: [
+                    tx.object(poolId),
+                    tx.object(this.addresses.pools.objects.poolRegistry),
+                    tx.object(this.addresses.pools.objects.protocolFeeVault),
+                    tx.object(this.addresses.pools.objects.treasury),
+                    tx.object(this.addresses.pools.objects.insuranceFund),
+                    tx.object(this.addresses.referralVault.objects.referralVault),
+                    ...coinIds.map((coinId) => typeof coinId === "string" ? tx.object(coinId) : coinId),
+                    tx.pure(expectedLpRatio.toString()),
+                    tx.pure(__1.Pools.normalizeSlippage(slippage)),
+                ],
+            });
+        };
+        this.multiCoinWithdrawTx = (inputs) => {
+            const { tx, poolId, lpCoinId, expectedAmountsOut, coinTypes, lpCoinType, slippage, withTransfer, } = inputs;
+            const poolSize = coinTypes.length;
+            return tx.add({
+                kind: "MoveCall",
+                target: utils_1.Helpers.transactions.createTxTarget(withTransfer
+                    ? this.addresses.pools.packages.ammInterface
+                    : this.addresses.pools.packages.amm, withTransfer
+                    ? PoolsApi.constants.moduleNames.interface
+                    : PoolsApi.constants.moduleNames.withdraw, `withdraw_${poolSize}_coins`),
+                typeArguments: [lpCoinType, ...coinTypes],
+                arguments: [
+                    tx.object(poolId),
+                    tx.object(this.addresses.pools.objects.poolRegistry),
+                    tx.object(this.addresses.pools.objects.protocolFeeVault),
+                    tx.object(this.addresses.pools.objects.treasury),
+                    tx.object(this.addresses.pools.objects.insuranceFund),
+                    tx.object(this.addresses.referralVault.objects.referralVault),
+                    typeof lpCoinId === "string" ? tx.object(lpCoinId) : lpCoinId,
+                    tx.pure(expectedAmountsOut.map((amount) => amount.toString())),
+                    tx.pure(__1.Pools.normalizeSlippage(slippage)),
+                ],
+            });
+        };
+        this.allCoinWithdrawTx = (inputs) => {
+            const { tx, poolId, lpCoinId, coinTypes, lpCoinType, withTransfer } = inputs;
+            const poolSize = coinTypes.length;
+            return tx.add({
+                kind: "MoveCall",
+                target: utils_1.Helpers.transactions.createTxTarget(withTransfer
+                    ? this.addresses.pools.packages.ammInterface
+                    : this.addresses.pools.packages.amm, withTransfer
+                    ? PoolsApi.constants.moduleNames.interface
+                    : PoolsApi.constants.moduleNames.withdraw, `all_coin_withdraw_${poolSize}_coins`),
+                typeArguments: [lpCoinType, ...coinTypes],
+                arguments: [
+                    tx.object(poolId),
+                    tx.object(this.addresses.pools.objects.poolRegistry),
+                    tx.object(this.addresses.pools.objects.protocolFeeVault),
+                    tx.object(this.addresses.pools.objects.treasury),
+                    tx.object(this.addresses.pools.objects.insuranceFund),
+                    tx.object(this.addresses.referralVault.objects.referralVault),
+                    typeof lpCoinId === "string" ? tx.object(lpCoinId) : lpCoinId,
+                ],
+            });
+        };
+        this.publishLpCoinTx = (inputs) => {
+            const { tx } = inputs;
+            const compiledModulesAndDeps = JSON.parse(this.addresses.pools.other.createLpCoinPackageCompilation);
+            return tx.publish({
+                modules: compiledModulesAndDeps.modules.map((m) => Array.from((0, sui_js_1.fromB64)(m))),
+                dependencies: compiledModulesAndDeps.dependencies.map((addr) => (0, sui_js_1.normalizeSuiObjectId)(addr)),
+            });
+        };
+        // TODO: handle bounds checks here instead of just on-chain ?
+        this.createPoolTx = (inputs) => __awaiter(this, void 0, void 0, function* () {
+            const { tx, lpCoinType, createPoolCapId, coinsInfo, lpCoinMetadata, lpCoinDescription, lpCoinIconUrl, } = inputs;
+            const poolSize = coinsInfo.length;
+            const coinTypes = coinsInfo.map((coin) => coin.coinType);
+            const decimals = coinsInfo.map((coin) => coin.decimals);
+            return tx.add({
+                kind: "MoveCall",
+                target: utils_1.Helpers.transactions.createTxTarget(this.addresses.pools.packages.ammInterface, PoolsApi.constants.moduleNames.interface, `create_pool_${poolSize}_coins`),
+                typeArguments: [lpCoinType, ...coinTypes],
+                arguments: [
+                    typeof createPoolCapId === "string"
+                        ? tx.object(createPoolCapId)
+                        : createPoolCapId,
+                    tx.object(this.addresses.pools.objects.poolRegistry),
+                    tx.pure(casting_1.Casting.u8VectorFromString(inputs.poolName), "vector<u8>"),
+                    tx.pure(casting_1.Casting.u8VectorFromString(lpCoinMetadata.name.toString()), "vector<u8>"),
+                    tx.pure(casting_1.Casting.u8VectorFromString(lpCoinMetadata.symbol.toString().toUpperCase()), "vector<u8>"),
+                    tx.pure(casting_1.Casting.u8VectorFromString(lpCoinDescription), "vector<u8>"),
+                    tx.pure(casting_1.Casting.u8VectorFromString(lpCoinIconUrl), "vector<u8>"),
+                    tx.pure(coinsInfo.map((coin) => coin.weight), "vector<u64>"),
+                    tx.pure(inputs.poolFlatness, "u64"),
+                    tx.pure(coinsInfo.map((coin) => coin.tradeFeeIn), "vector<u64>"),
+                    tx.pure(coinsInfo.map((coin) => coin.tradeFeeOut), "vector<u64>"),
+                    tx.pure(coinsInfo.map((coin) => coin.depositFee), "vector<u64>"),
+                    tx.pure(coinsInfo.map((coin) => coin.withdrawFee), "vector<u64>"),
+                    ...coinsInfo.map((coin) => typeof coin.coinId === "string"
+                        ? tx.object(coin.coinId)
+                        : coin.coinId),
+                    tx.pure(utils_1.Helpers.transactions.createOptionObject(decimals.includes(undefined) ? undefined : decimals), "Option<vector<u8>>"),
+                    tx.pure(inputs.respectDecimals, "bool"),
+                    tx.pure(utils_1.Helpers.transactions.createOptionObject(inputs.forceLpDecimals), "Option<u8>"), // force_lp_decimals
+                ],
+            });
+        });
+        this.poolObjectIdForLpCoinTypeTx = (inputs) => {
+            const { tx, lpCoinType } = inputs;
+            return tx.moveCall({
+                target: utils_1.Helpers.transactions.createTxTarget(this.addresses.pools.packages.amm, PoolsApi.constants.moduleNames.poolRegistry, "lp_type_to_pool_id"),
+                typeArguments: [lpCoinType],
+                arguments: [tx.object(this.addresses.pools.objects.poolRegistry)],
+            });
+        };
+        // =========================================================================
+        //  Inspections
+        // =========================================================================
+        this.fetchPoolObjectIdForLpCoinType = (inputs) => __awaiter(this, void 0, void 0, function* () {
+            const tx = new sui_js_1.TransactionBlock();
+            this.poolObjectIdForLpCoinTypeTx(Object.assign({ tx }, inputs));
             const bytes = yield this.Provider.Inspections().fetchFirstBytesFromTxOutput(tx);
             return casting_1.Casting.addressFromBytes(bytes);
         });
@@ -149,27 +501,33 @@ class PoolsApi {
             const uniqueCoins = utils_1.Helpers.uniqueArray(allCoins);
             return uniqueCoins;
         });
-        /////////////////////////////////////////////////////////////////////
-        //// Stats
-        /////////////////////////////////////////////////////////////////////
+        // =========================================================================
+        //  Stats
+        // =========================================================================
         // TODO: use promise.all to execute some of this fetching in parallel
         this.fetchPoolStats = (inputs) => __awaiter(this, void 0, void 0, function* () {
             const { pool, coinsToPrice, coinsToDecimals } = inputs;
             const poolCoins = pool.pool.coins;
             // TODO: remove all notions of sdk from api functions !
-            const tradeEventsWithinTime = yield this.Provider.Events().fetchEventsWithinTime((cursor, limit) => pool.getTradeEvents({
-                cursor,
-                limit,
-            }), "hour", 24, 512);
-            const volume = this.Helpers.fetchCalcPoolVolume(tradeEventsWithinTime, coinsToPrice, coinsToDecimals);
-            const tvl = yield this.Helpers.fetchCalcPoolTvl(pool.pool.coins, coinsToPrice, coinsToDecimals);
-            const supplyPerLps = this.Helpers.calcPoolSupplyPerLps(poolCoins, pool.pool.lpCoinSupply);
-            const lpPrice = this.Helpers.calcPoolLpPrice(pool.pool.lpCoinSupply, tvl);
+            const tradeEventsWithinTime = yield this.Provider.Events().fetchEventsWithinTime({
+                fetchEventsFunc: (eventsInputs) => pool.getTradeEvents(eventsInputs),
+                timeUnit: "hour",
+                time: 24,
+                limitStepSize: 512,
+            });
+            const volume = this.fetchCalcPoolVolume(tradeEventsWithinTime, coinsToPrice, coinsToDecimals);
+            const tvl = yield this.fetchCalcPoolTvl({
+                poolCoins: pool.pool.coins,
+                coinsToPrice,
+                coinsToDecimals,
+            });
+            const supplyPerLps = this.calcPoolSupplyPerLps(poolCoins, pool.pool.lpCoinSupply);
+            const lpPrice = this.calcPoolLpPrice(pool.pool.lpCoinSupply, tvl);
             // this is okay since all trade fees are currently the same for every coin
             const firstCoin = Object.values(pool.pool.coins)[0];
             const fees = volume *
                 __1.Pools.tradeFeeWithDecimals(firstCoin.tradeFeeIn + firstCoin.tradeFeeOut);
-            const apy = this.Helpers.calcApy({
+            const apy = this.calcApy({
                 fees24Hours: fees,
                 tvl,
             });
@@ -182,9 +540,48 @@ class PoolsApi {
                 apy,
             };
         });
-        /////////////////////////////////////////////////////////////////////
-        //// Prices
-        /////////////////////////////////////////////////////////////////////
+        // NOTE: should this volume calculation also take into account deposits and withdraws
+        // (not just swaps) ?
+        this.fetchCalcPoolVolume = (tradeEvents, coinsToPrice, coinsToDecimals) => {
+            let volume = 0;
+            for (const trade of tradeEvents) {
+                for (const [index, typeIn] of trade.typesIn.entries()) {
+                    const decimals = coinsToDecimals[typeIn];
+                    const tradeAmount = coin_1.Coin.balanceWithDecimals(trade.amountsIn[index], decimals);
+                    const coinInPrice = coinsToPrice[typeIn];
+                    const amountUsd = coinInPrice < 0 ? 0 : tradeAmount * coinInPrice;
+                    volume += amountUsd;
+                }
+            }
+            return volume;
+        };
+        this.fetchCalcPoolTvl = (inputs) => __awaiter(this, void 0, void 0, function* () {
+            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.calcPoolSupplyPerLps = (poolCoins, lpSupply) => {
+            const supplyPerLps = Object.values(poolCoins).map((poolCoin) => Number(poolCoin.balance) / Number(lpSupply));
+            return supplyPerLps;
+        };
+        this.calcPoolLpPrice = (lpSupply, tvl) => {
+            const lpCoinDecimals = __1.Pools.constants.decimals.lpCoinDecimals;
+            const lpPrice = Number(Number(tvl) / coin_1.Coin.balanceWithDecimals(lpSupply, lpCoinDecimals));
+            return lpPrice;
+        };
+        this.calcApy = (inputs) => {
+            const { fees24Hours, tvl } = inputs;
+            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 ?
@@ -224,15 +621,15 @@ class PoolsApi {
             }
             return lpCoinsToPrice;
         });
-        /////////////////////////////////////////////////////////////////////
-        //// Graph Data
-        /////////////////////////////////////////////////////////////////////
+        // =========================================================================
+        //  Graph Data
+        // =========================================================================
         this.fetchPoolVolumeData = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            const timeframeValue = this.Helpers.poolVolumeDataTimeframes[inputs.timeframe];
-            const tradeEvents = (yield this.Provider.Events().fetchEventsWithinTime(
-            // TODO: fetch only pool's events
-            this.fetchTradeEvents, timeframeValue.timeUnit, timeframeValue.time, 512)).filter((trade) => trade.poolId === inputs.poolObjectId);
-            return this.Helpers.calcPoolVolumeData(Object.assign(Object.assign(Object.assign({}, inputs), timeframeValue), { tradeEvents, buckets: timeframeValue.time }));
+            const timeframeValue = this.poolVolumeDataTimeframes[inputs.timeframe];
+            const tradeEvents = (yield this.Provider.Events().fetchEventsWithinTime(Object.assign(Object.assign({ 
+                // TODO: fetch only pool's events
+                fetchEventsFunc: this.fetchTradeEvents }, timeframeValue), { limitStepSize: 512 }))).filter((trade) => trade.poolId === inputs.poolObjectId);
+            return this.calcPoolVolumeData(Object.assign(Object.assign(Object.assign({}, inputs), timeframeValue), { tradeEvents, buckets: timeframeValue.time }));
         });
         this.calcPoolFeeDataFromVolume = (inputs) => {
             const feeData = inputs.volumeData.map((data) => ({
@@ -241,8 +638,102 @@ class PoolsApi {
             }));
             return feeData;
         };
-        this.Provider = Provider;
-        this.Helpers = new poolsApiHelpers_1.PoolsApiHelpers(Provider);
+        this.calcPoolVolumeData = (inputs) => {
+            const { tradeEvents, timeUnit, time, buckets, coinsToDecimals, coinsToPrice, } = inputs;
+            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
+        // =========================================================================
+        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 ? "" : ", "), "")})`;
+        });
+        // =========================================================================
+        //  Helpers
+        // =========================================================================
+        // PRODUCTION: should this perform a dev inspect to pool registry instead of using string alone ?
+        this.isLpCoin = (coin) => {
+            return (coin.split("::").length === 3 &&
+                coin.split("::")[1].includes("af_lp") &&
+                coin.split("::")[2].includes("AF_LP"));
+        };
+        // =========================================================================
+        //  Private Methods
+        // =========================================================================
+        // =========================================================================
+        //  Event Types
+        // =========================================================================
+        this.tradeEventType = () => eventsApiHelpers_1.EventsApiHelpers.createEventType(this.addresses.pools.packages.events, PoolsApi.constants.moduleNames.events, PoolsApi.constants.eventNames.swap);
+        this.depositEventType = () => eventsApiHelpers_1.EventsApiHelpers.createEventType(this.addresses.pools.packages.events, PoolsApi.constants.moduleNames.events, PoolsApi.constants.eventNames.deposit);
+        this.withdrawEventType = () => eventsApiHelpers_1.EventsApiHelpers.createEventType(this.addresses.pools.packages.events, PoolsApi.constants.moduleNames.events, PoolsApi.constants.eventNames.withdraw);
+        const addresses = {
+            pools: Provider.addresses.pools,
+            referralVault: Provider.addresses.referralVault,
+            routerWrapper: (_a = Provider.addresses.router) === null || _a === void 0 ? void 0 : _a.aftermath,
+        };
+        if (!addresses.pools || !addresses.referralVault)
+            throw new Error("not all required addresses have been set in provider");
+        // @ts-ignore
+        this.addresses = addresses;
+        this.eventTypes = {
+            trade: this.tradeEventType(),
+            deposit: this.depositEventType(),
+            withdraw: this.withdrawEventType(),
+        };
     }
 }
 exports.PoolsApi = PoolsApi;
+// =========================================================================
+//  Constants
+// =========================================================================
+PoolsApi.constants = {
+    moduleNames: {
+        interface: "amm_interface",
+        pool: "pool",
+        swap: "swap",
+        deposit: "deposit",
+        withdraw: "withdraw",
+        events: "events",
+        poolRegistry: "pool_registry",
+        routerWrapper: "aftermath",
+    },
+    eventNames: {
+        swap: "SwapEvent",
+        deposit: "DepositEvent",
+        withdraw: "WithdrawEvent",
+    },
+    defaultLpCoinIconImageUrl: "https://aftermath.finance/coins/lp/af_lp.svg",
+    blacklistedPoolIds: [""],
+};