aftermath-ts-sdk 1.1.73 → 1.1.75

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

@@ -61,10 +61,10 @@ class PoolsApi {
         });
         this.fetchPools = (inputs) => __awaiter(this, void 0, void 0, function* () {
             const poolIds = inputs.objectIds.map((objectId) => utils_2.Helpers.addLeadingZeroesToType(objectId));
-            const uncastPools = yield this.Provider.indexerCaller.fetchIndexer("pools", undefined, {
+            const response = yield this.Provider.indexerCaller.fetchIndexer("pools", undefined, {
                 pool_ids: poolIds,
             });
-            const pools = uncastPools.map(poolsApiCasting_1.PoolsApiCasting.poolObjectFromIndexer);
+            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
@@ -76,9 +76,366 @@ class PoolsApi {
          * @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 uncastPools = yield this.Provider.indexerCaller.fetchIndexer("pools");
-            return uncastPools.map(poolsApiCasting_1.PoolsApiCasting.poolObjectFromIndexer);
+            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)
+                throw new Error("dao fee pool addresses have not been set in provider");
+            return this.Provider.Objects().fetchCastObjectsOwnedByAddressOfType({
+                walletAddress,
+                objectType: this.objectTypes.daoFeePoolOwnerCap,
+                objectFromSuiObjectResponse: casting_1.Casting.pools.daoFeePoolOwnerCapObjectFromSuiObjectResponse,
+            });
+        });
+        // =========================================================================
+        //  Transaction Commands
+        // =========================================================================
+        /**
+         * Executes a trade transaction on the specified pool.
+         * @param inputs An object containing the necessary inputs for the trade transaction.
+         * @returns A `TransactionObjectArgument` representing the trade transaction.
+         */
+        this.tradeTx = (inputs) => {
+            const { tx, poolId, coinInId, coinInType, expectedCoinOutAmount, coinOutType, lpCoinType, slippage, withTransfer, } = inputs;
+            return tx.moveCall({
+                target: utils_2.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.u64(expectedCoinOutAmount.toString()),
+                    tx.pure.u64(pools_1.Pools.normalizeInvertSlippage(slippage)),
+                ],
+            });
+        };
+        /**
+         * Creates a transaction object argument for depositing multiple coins into a pool.
+         *
+         * @param inputs - An object containing the necessary parameters for the deposit transaction.
+         * @returns A transaction object argument representing the deposit transaction.
+         */
+        this.multiCoinDepositTx = (inputs) => {
+            const { tx, poolId, coinIds, coinTypes, expectedLpRatio, lpCoinType, slippage, withTransfer, } = inputs;
+            const poolSize = coinTypes.length;
+            return tx.moveCall({
+                target: utils_2.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.u128(expectedLpRatio.toString()),
+                    tx.pure.u64(pools_1.Pools.normalizeInvertSlippage(slippage)),
+                ],
+            });
+        };
+        /**
+         * Withdraws multiple coins from a pool.
+         * @param inputs An object containing the necessary parameters for the transaction.
+         * @returns A TransactionObjectArgument representing the transaction.
+         */
+        this.multiCoinWithdrawTx = (inputs) => {
+            const { tx, poolId, lpCoinId, expectedAmountsOut, coinTypes, lpCoinType, slippage, withTransfer, } = inputs;
+            const poolSize = coinTypes.length;
+            return tx.moveCall({
+                target: utils_2.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(bcs_1.bcs
+                        .vector(bcs_1.bcs.u64())
+                        .serialize(expectedAmountsOut.map((amount) => amount.toString()))),
+                    tx.pure.u64(pools_1.Pools.normalizeInvertSlippage(slippage)),
+                ],
+            });
+        };
+        /**
+         * Withdraws all coins from a liquidity pool.
+         * @param inputs - The inputs required for the transaction.
+         * @param inputs.tx - The transaction block.
+         * @param inputs.poolId - The ID of the liquidity pool.
+         * @param inputs.lpCoinId - The ID of the LP coin.
+         * @param inputs.lpCoinType - The type of the LP coin.
+         * @param inputs.coinTypes - An array of coin types.
+         * @param inputs.withTransfer - Whether or not to include a transfer.
+         * @returns An array of transaction objects.
+         */
+        this.allCoinWithdrawTx = (inputs) => {
+            const { tx, poolId, lpCoinId, coinTypes, lpCoinType, withTransfer } = inputs;
+            const poolSize = coinTypes.length;
+            return tx.moveCall({
+                target: utils_2.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,
+                ],
+            });
+        };
+        /**
+         * Publishes a transaction block for creating a liquidity pool coin.
+         * @param inputs An object containing the transaction block and the decimal value of the liquidity pool coin.
+         * @returns A promise that resolves to the result of the transaction publishing.
+         */
+        this.publishLpCoinTx = (inputs) => {
+            var _a;
+            const compilations = (_a = this.addresses.pools.other) === null || _a === void 0 ? void 0 : _a.createLpCoinPackageCompilations;
+            if (!compilations)
+                throw new Error("not all required addresses have been set in provider for lp coin publishing (requires package compilations)");
+            const { tx, lpCoinDecimals } = inputs;
+            const compiledModulesAndDeps = JSON.parse(compilations[lpCoinDecimals]);
+            return tx.publish({
+                modules: compiledModulesAndDeps.modules.map((m) => Array.from((0, utils_1.fromB64)(m))),
+                dependencies: compiledModulesAndDeps.dependencies.map((addr) => (0, utils_1.normalizeSuiObjectId)(addr)),
+            });
+        };
+        // TODO: handle bounds checks here instead of just on-chain ?
+        /**
+         * Creates a transaction to create a new pool.
+         * @param inputs - An object containing the necessary inputs to create the pool.
+         * @returns A transaction block to create the pool.
+         */
+        this.createPoolTx = (inputs) => {
+            const { tx, lpCoinType, createPoolCapId, coinsInfo, lpCoinMetadata, lpCoinDescription, lpCoinIconUrl, withTransfer, } = inputs;
+            const poolSize = coinsInfo.length;
+            const coinTypes = coinsInfo.map((coin) => coin.coinType);
+            const decimals = coinsInfo.map((coin) => coin.decimals);
+            return tx.moveCall({
+                target: utils_2.Helpers.transactions.createTxTarget(withTransfer
+                    ? this.addresses.pools.packages.ammInterface
+                    : this.addresses.pools.packages.amm, withTransfer
+                    ? PoolsApi.constants.moduleNames.interface
+                    : PoolsApi.constants.moduleNames.poolFactory, `create_pool_${poolSize}_coins`),
+                typeArguments: [lpCoinType, ...coinTypes],
+                arguments: [
+                    typeof createPoolCapId === "string"
+                        ? tx.object(createPoolCapId)
+                        : createPoolCapId,
+                    tx.object(this.addresses.pools.objects.poolRegistry),
+                    tx.pure(bcs_1.bcs
+                        .vector(bcs_1.bcs.u8())
+                        .serialize(casting_1.Casting.u8VectorFromString(inputs.poolName))),
+                    tx.pure(bcs_1.bcs
+                        .vector(bcs_1.bcs.u8())
+                        .serialize(casting_1.Casting.u8VectorFromString(lpCoinMetadata.name.toString()))),
+                    tx.pure(bcs_1.bcs
+                        .vector(bcs_1.bcs.u8())
+                        .serialize(casting_1.Casting.u8VectorFromString(lpCoinMetadata.symbol.toString().toUpperCase()))),
+                    tx.pure(bcs_1.bcs
+                        .vector(bcs_1.bcs.u8())
+                        .serialize(casting_1.Casting.u8VectorFromString(lpCoinDescription))),
+                    tx.pure(bcs_1.bcs
+                        .vector(bcs_1.bcs.u8())
+                        .serialize(casting_1.Casting.u8VectorFromString(lpCoinIconUrl))),
+                    tx.pure(bcs_1.bcs
+                        .vector(bcs_1.bcs.u64())
+                        .serialize(coinsInfo.map((coin) => coin.weight))),
+                    tx.pure.u64(inputs.poolFlatness),
+                    tx.pure(bcs_1.bcs
+                        .vector(bcs_1.bcs.u64())
+                        .serialize(coinsInfo.map((coin) => coin.tradeFeeIn))),
+                    tx.pure(bcs_1.bcs
+                        .vector(bcs_1.bcs.u64())
+                        .serialize(coinsInfo.map((coin) => coin.tradeFeeOut))),
+                    tx.pure(bcs_1.bcs
+                        .vector(bcs_1.bcs.u64())
+                        .serialize(coinsInfo.map((coin) => coin.depositFee))),
+                    tx.pure(bcs_1.bcs
+                        .vector(bcs_1.bcs.u64())
+                        .serialize(coinsInfo.map((coin) => coin.withdrawFee))),
+                    ...coinsInfo.map((coin) => typeof coin.coinId === "string"
+                        ? tx.object(coin.coinId)
+                        : coin.coinId),
+                    tx.pure(bcs_1.bcs
+                        .option(bcs_1.bcs.vector(bcs_1.bcs.u8()))
+                        .serialize(decimals.includes(undefined)
+                        ? undefined
+                        : decimals)),
+                    tx.pure.bool(inputs.respectDecimals),
+                    tx.pure(bcs_1.bcs.option(bcs_1.bcs.u8()).serialize(inputs.forceLpDecimals)), // force_lp_decimals
+                ],
+            });
+        };
+        /**
+         * Returns the pool object ID for a given LP coin type transaction.
+         * @param inputs - An object containing the transaction block and LP coin type.
+         * @returns The pool object ID.
+         */
+        this.poolObjectIdForLpCoinTypeTx = (inputs) => {
+            const { tx, lpCoinType } = inputs;
+            return tx.moveCall({
+                target: utils_2.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)],
+            });
+        };
+        this.daoFeePoolNewTx = (inputs) => {
+            const { tx, poolId } = inputs;
+            if (!this.addresses.daoFeePools)
+                throw new Error("dao fee pool addresses have not been set in provider");
+            return tx.moveCall({
+                target: utils_2.Helpers.transactions.createTxTarget(this.addresses.daoFeePools.packages.amm, PoolsApi.constants.moduleNames.pool, "new"),
+                typeArguments: [inputs.lpCoinType],
+                arguments: [
+                    typeof poolId === "string" ? tx.object(poolId) : poolId,
+                    tx.object(this.addresses.daoFeePools.objects.version),
+                    tx.pure.u16(Number(inputs.feeBps)),
+                    tx.pure.address(inputs.feeRecipient),
+                ],
+            });
+        };
+        this.daoFeePoolUpdateFeeBpsTx = (inputs) => {
+            const { tx } = inputs;
+            if (!this.addresses.daoFeePools)
+                throw new Error("dao fee pool addresses have not been set in provider");
+            return tx.moveCall({
+                target: utils_2.Helpers.transactions.createTxTarget(this.addresses.daoFeePools.packages.amm, PoolsApi.constants.moduleNames.pool, "update_fee_bps"),
+                typeArguments: [inputs.lpCoinType],
+                arguments: [
+                    tx.object(inputs.daoFeePoolOwnerCapId),
+                    tx.object(inputs.daoFeePoolId),
+                    tx.object(this.addresses.daoFeePools.objects.version),
+                    tx.pure.u16(Number(inputs.newFeeBps)),
+                ],
+            });
+        };
+        this.daoFeePoolUpdateFeeRecipientTx = (inputs) => {
+            const { tx } = inputs;
+            if (!this.addresses.daoFeePools)
+                throw new Error("dao fee pool addresses have not been set in provider");
+            return tx.moveCall({
+                target: utils_2.Helpers.transactions.createTxTarget(this.addresses.daoFeePools.packages.amm, PoolsApi.constants.moduleNames.pool, "update_fee_recipient"),
+                typeArguments: [inputs.lpCoinType],
+                arguments: [
+                    tx.object(inputs.daoFeePoolOwnerCapId),
+                    tx.object(inputs.daoFeePoolId),
+                    tx.object(this.addresses.daoFeePools.objects.version),
+                    tx.pure.address(inputs.newFeeRecipient),
+                ],
+            });
+        };
+        /**
+         * Executes a trade transaction on the specified pool.
+         * @param inputs An object containing the necessary inputs for the trade transaction.
+         * @returns A `TransactionObjectArgument` representing the trade transaction.
+         */
+        this.daoFeePoolTradeTx = (inputs) => {
+            const { tx, daoFeePoolId, coinInId, coinInType, expectedCoinOutAmount, coinOutType, lpCoinType, slippage, } = inputs;
+            if (!this.addresses.daoFeePools)
+                throw new Error("dao fee pool addresses have not been set in provider");
+            return tx.moveCall({
+                target: utils_2.Helpers.transactions.createTxTarget(this.addresses.daoFeePools.packages.amm, PoolsApi.constants.moduleNames.swap, "swap_exact_in"),
+                typeArguments: [lpCoinType, coinInType, coinOutType],
+                arguments: [
+                    tx.object(daoFeePoolId),
+                    tx.object(this.addresses.daoFeePools.objects.version),
+                    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.u64(expectedCoinOutAmount.toString()),
+                    tx.pure.u64(pools_1.Pools.normalizeInvertSlippage(slippage)),
+                ],
+            });
+        };
+        /**
+         * Creates a transaction object argument for depositing multiple coins into a pool.
+         *
+         * @param inputs - An object containing the necessary parameters for the deposit transaction.
+         * @returns A transaction object argument representing the deposit transaction.
+         */
+        this.daoFeePoolMultiCoinDepositTx = (inputs) => {
+            const { tx, daoFeePoolId, coinIds, coinTypes, expectedLpRatio, lpCoinType, slippage, } = inputs;
+            if (!this.addresses.daoFeePools)
+                throw new Error("dao fee pool addresses have not been set in provider");
+            const poolSize = coinTypes.length;
+            return tx.moveCall({
+                target: utils_2.Helpers.transactions.createTxTarget(this.addresses.daoFeePools.packages.amm, PoolsApi.constants.moduleNames.deposit, `deposit_${poolSize}_coins`),
+                typeArguments: [lpCoinType, ...coinTypes],
+                arguments: [
+                    tx.object(daoFeePoolId),
+                    tx.object(this.addresses.daoFeePools.objects.version),
+                    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.u128(expectedLpRatio.toString()),
+                    tx.pure.u64(pools_1.Pools.normalizeInvertSlippage(slippage)),
+                ],
+            });
+        };
+        /**
+         * Withdraws all coins from a liquidity pool.
+         * @param inputs - The inputs required for the transaction.
+         * @param inputs.tx - The transaction block.
+         * @param inputs.poolId - The ID of the liquidity pool.
+         * @param inputs.lpCoinId - The ID of the LP coin.
+         * @param inputs.lpCoinType - The type of the LP coin.
+         * @param inputs.coinTypes - An array of coin types.
+         * @returns An array of transaction objects.
+         */
+        this.daoFeePoolAllCoinWithdrawTx = (inputs) => {
+            const { tx, daoFeePoolId, lpCoinId, coinTypes, lpCoinType } = inputs;
+            if (!this.addresses.daoFeePools)
+                throw new Error("dao fee pool addresses have not been set in provider");
+            const poolSize = coinTypes.length;
+            return tx.moveCall({
+                target: utils_2.Helpers.transactions.createTxTarget(this.addresses.daoFeePools.packages.amm, PoolsApi.constants.moduleNames.withdraw, `all_coin_withdraw_${poolSize}_coins`),
+                typeArguments: [lpCoinType, ...coinTypes],
+                arguments: [
+                    tx.object(daoFeePoolId),
+                    tx.object(this.addresses.daoFeePools.objects.version),
+                    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,
+                ],
+            });
+        };
         // =========================================================================
         //  Transaction Builders
         // =========================================================================
@@ -146,17 +503,32 @@ class PoolsApi {
                 coinAmount: coinInAmount,
                 isSponsoredTx,
             });
-            this.tradeTx({
-                tx,
-                coinInId,
-                poolId: pool.pool.objectId,
-                expectedCoinOutAmount: amountOut,
-                lpCoinType: pool.pool.lpCoinType,
-                coinInType,
-                coinOutType,
-                slippage,
-                withTransfer: true,
-            });
+            if (pool.pool.daoFeePoolObject) {
+                const coinOutId = this.daoFeePoolTradeTx({
+                    tx,
+                    coinInId,
+                    daoFeePoolId: pool.pool.daoFeePoolObject.objectId,
+                    expectedCoinOutAmount: amountOut,
+                    lpCoinType: pool.pool.lpCoinType,
+                    coinInType,
+                    coinOutType,
+                    slippage,
+                });
+                tx.transferObjects([coinOutId], walletAddress);
+            }
+            else {
+                this.tradeTx({
+                    tx,
+                    coinInId,
+                    poolId: pool.pool.objectId,
+                    expectedCoinOutAmount: amountOut,
+                    lpCoinType: pool.pool.lpCoinType,
+                    coinInType,
+                    coinOutType,
+                    slippage,
+                    withTransfer: true,
+                });
+            }
             return tx;
         });
         this.fetchAddTradeTx = (inputs) => __awaiter(this, void 0, void 0, function* () {
@@ -207,18 +579,32 @@ class PoolsApi {
             const expectedLpRatio = casting_1.Casting.numberToFixedBigInt(lpRatio);
             const coinIds = yield this.Provider.Coin().fetchCoinsWithAmountTx(Object.assign(Object.assign({}, inputs), { tx,
                 coinTypes,
-                coinAmounts,
-                isSponsoredTx }));
-            this.multiCoinDepositTx({
-                tx,
-                poolId: pool.pool.objectId,
-                lpCoinType: pool.pool.lpCoinType,
-                coinIds,
-                coinTypes,
-                expectedLpRatio,
-                slippage,
-                withTransfer: true,
-            });
+                coinAmounts,
+                isSponsoredTx }));
+            if (pool.pool.daoFeePoolObject) {
+                const lpCoinId = this.daoFeePoolMultiCoinDepositTx({
+                    tx,
+                    daoFeePoolId: pool.pool.daoFeePoolObject.objectId,
+                    lpCoinType: pool.pool.lpCoinType,
+                    coinIds,
+                    coinTypes,
+                    expectedLpRatio,
+                    slippage,
+                });
+                tx.transferObjects([lpCoinId], walletAddress);
+            }
+            else {
+                this.multiCoinDepositTx({
+                    tx,
+                    poolId: pool.pool.objectId,
+                    lpCoinType: pool.pool.lpCoinType,
+                    coinIds,
+                    coinTypes,
+                    expectedLpRatio,
+                    slippage,
+                    withTransfer: true,
+                });
+            }
             return tx;
         });
         /**
@@ -256,16 +642,22 @@ class PoolsApi {
                 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,
-            });
+            if (pool.pool.daoFeePoolObject) {
+                // TODO: handle dao fee pool
+                // TODO: handle transfer
+            }
+            else {
+                this.multiCoinWithdrawTx({
+                    tx,
+                    poolId: pool.pool.objectId,
+                    lpCoinType: pool.pool.lpCoinType,
+                    expectedAmountsOut: coinAmounts,
+                    coinTypes: coinTypes,
+                    lpCoinId,
+                    slippage,
+                    withTransfer: true,
+                });
+            }
             return tx;
         });
         /**
@@ -289,14 +681,26 @@ class PoolsApi {
                 coinAmount: lpCoinAmount,
             });
             const coinTypes = Object.keys(pool.pool.coins);
-            this.allCoinWithdrawTx({
-                tx,
-                poolId: pool.pool.objectId,
-                lpCoinType: pool.pool.lpCoinType,
-                coinTypes,
-                lpCoinId,
-                withTransfer: true,
-            });
+            if (pool.pool.daoFeePoolObject) {
+                const withdrawnCoinIds = this.daoFeePoolAllCoinWithdrawTx({
+                    tx,
+                    daoFeePoolId: pool.pool.daoFeePoolObject.objectId,
+                    lpCoinType: pool.pool.lpCoinType,
+                    coinTypes,
+                    lpCoinId,
+                });
+                tx.transferObjects(coinTypes.map((_, index) => withdrawnCoinIds[index]), walletAddress);
+            }
+            else {
+                this.allCoinWithdrawTx({
+                    tx,
+                    poolId: pool.pool.objectId,
+                    lpCoinType: pool.pool.lpCoinType,
+                    coinTypes,
+                    lpCoinId,
+                    withTransfer: true,
+                });
+            }
             return tx;
         });
         /**
@@ -318,7 +722,7 @@ class PoolsApi {
          * @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 } = inputs;
+            const { coinsInfo, isSponsoredTx, burnLpCoin, lpCoinType, daoFeeInfo } = inputs;
             const tx = new transactions_1.Transaction();
             tx.setSender(inputs.walletAddress);
             // TODO: make this fetching work
@@ -348,241 +752,54 @@ class PoolsApi {
                 coinsInfo: coinsInfo.map((info, index) => {
                     return Object.assign(Object.assign({}, info), { coinId: coinArgs[index] });
                 }), lpCoinDescription });
-            if (burnLpCoin) {
-                const [poolId, lpCoinId] = yield this.createPoolTx(createPoolTxArgs);
-                this.Provider.Objects().publicShareObjectTx({
+            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,
-                    object: poolId,
-                    objectType: `${this.objectTypes.pool}<${lpCoinType}>`,
+                    poolId,
+                    lpCoinType,
+                    feeRecipient: daoFeeInfo.feeRecipient,
+                    feeBps: casting_1.Casting.percentageToBps(daoFeeInfo.feePercentage),
                 });
-                this.Provider.Objects().burnObjectTx({
+                this.Provider.Objects().publicShareObjectTx({
                     tx,
-                    object: lpCoinId,
+                    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 {
-                yield this.createPoolTx(Object.assign(Object.assign({}, createPoolTxArgs), { withTransfer: true }));
+                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;
         });
-        // =========================================================================
-        //  Transaction Commands
-        // =========================================================================
-        /**
-         * Executes a trade transaction on the specified pool.
-         * @param inputs An object containing the necessary inputs for the trade transaction.
-         * @returns A `TransactionObjectArgument` representing the trade transaction.
-         */
-        this.tradeTx = (inputs) => {
-            const { tx, poolId, coinInId, coinInType, expectedCoinOutAmount, coinOutType, lpCoinType, slippage, withTransfer, } = inputs;
-            return tx.moveCall({
-                target: utils_2.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.u64(expectedCoinOutAmount.toString()),
-                    tx.pure.u64(pools_1.Pools.normalizeSlippage(slippage)),
-                ],
-            });
-        };
-        /**
-         * Creates a transaction object argument for depositing multiple coins into a pool.
-         *
-         * @param inputs - An object containing the necessary parameters for the deposit transaction.
-         * @returns A transaction object argument representing the deposit transaction.
-         */
-        this.multiCoinDepositTx = (inputs) => {
-            const { tx, poolId, coinIds, coinTypes, expectedLpRatio, lpCoinType, slippage, withTransfer, } = inputs;
-            const poolSize = coinTypes.length;
-            return tx.moveCall({
-                target: utils_2.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.u128(expectedLpRatio.toString()),
-                    tx.pure.u64(pools_1.Pools.normalizeSlippage(slippage)),
-                ],
-            });
-        };
-        /**
-         * Withdraws multiple coins from a pool.
-         * @param inputs An object containing the necessary parameters for the transaction.
-         * @returns A TransactionObjectArgument representing the transaction.
-         */
-        this.multiCoinWithdrawTx = (inputs) => {
-            const { tx, poolId, lpCoinId, expectedAmountsOut, coinTypes, lpCoinType, slippage, withTransfer, } = inputs;
-            const poolSize = coinTypes.length;
-            return tx.moveCall({
-                target: utils_2.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(bcs_1.bcs
-                        .vector(bcs_1.bcs.u64())
-                        .serialize(expectedAmountsOut.map((amount) => amount.toString()))),
-                    tx.pure.u64(pools_1.Pools.normalizeSlippage(slippage)),
-                ],
-            });
-        };
-        /**
-         * Withdraws all coins from a liquidity pool.
-         * @param inputs - The inputs required for the transaction.
-         * @param inputs.tx - The transaction block.
-         * @param inputs.poolId - The ID of the liquidity pool.
-         * @param inputs.lpCoinId - The ID of the LP coin.
-         * @param inputs.lpCoinType - The type of the LP coin.
-         * @param inputs.coinTypes - An array of coin types.
-         * @param inputs.withTransfer - Whether or not to include a transfer.
-         * @returns An array of transaction objects.
-         */
-        this.allCoinWithdrawTx = (inputs) => {
-            const { tx, poolId, lpCoinId, coinTypes, lpCoinType, withTransfer } = inputs;
-            const poolSize = coinTypes.length;
-            return tx.moveCall({
-                target: utils_2.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,
-                ],
-            });
-        };
-        /**
-         * Publishes a transaction block for creating a liquidity pool coin.
-         * @param inputs An object containing the transaction block and the decimal value of the liquidity pool coin.
-         * @returns A promise that resolves to the result of the transaction publishing.
-         */
-        this.publishLpCoinTx = (inputs) => {
-            var _a;
-            const compilations = (_a = this.addresses.pools.other) === null || _a === void 0 ? void 0 : _a.createLpCoinPackageCompilations;
-            if (!compilations)
-                throw new Error("not all required addresses have been set in provider for lp coin publishing (requires pacakge compilations)");
-            const { tx, lpCoinDecimals } = inputs;
-            const compiledModulesAndDeps = JSON.parse(compilations[lpCoinDecimals]);
-            return tx.publish({
-                modules: compiledModulesAndDeps.modules.map((m) => Array.from((0, utils_1.fromB64)(m))),
-                dependencies: compiledModulesAndDeps.dependencies.map((addr) => (0, utils_1.normalizeSuiObjectId)(addr)),
-            });
-        };
-        // TODO: handle bounds checks here instead of just on-chain ?
-        /**
-         * Creates a transaction to create a new pool.
-         * @param inputs - An object containing the necessary inputs to create the pool.
-         * @returns A transaction block to create the pool.
-         */
-        this.createPoolTx = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            const { tx, lpCoinType, createPoolCapId, coinsInfo, lpCoinMetadata, lpCoinDescription, lpCoinIconUrl, withTransfer, } = inputs;
-            const poolSize = coinsInfo.length;
-            const coinTypes = coinsInfo.map((coin) => coin.coinType);
-            const decimals = coinsInfo.map((coin) => coin.decimals);
-            return tx.moveCall({
-                target: utils_2.Helpers.transactions.createTxTarget(withTransfer
-                    ? this.addresses.pools.packages.ammInterface
-                    : this.addresses.pools.packages.amm, withTransfer
-                    ? PoolsApi.constants.moduleNames.interface
-                    : PoolsApi.constants.moduleNames.poolFactory, `create_pool_${poolSize}_coins`),
-                typeArguments: [lpCoinType, ...coinTypes],
-                arguments: [
-                    typeof createPoolCapId === "string"
-                        ? tx.object(createPoolCapId)
-                        : createPoolCapId,
-                    tx.object(this.addresses.pools.objects.poolRegistry),
-                    tx.pure(bcs_1.bcs
-                        .vector(bcs_1.bcs.u8())
-                        .serialize(casting_1.Casting.u8VectorFromString(inputs.poolName))),
-                    tx.pure(bcs_1.bcs
-                        .vector(bcs_1.bcs.u8())
-                        .serialize(casting_1.Casting.u8VectorFromString(lpCoinMetadata.name.toString()))),
-                    tx.pure(bcs_1.bcs
-                        .vector(bcs_1.bcs.u8())
-                        .serialize(casting_1.Casting.u8VectorFromString(lpCoinMetadata.symbol.toString().toUpperCase()))),
-                    tx.pure(bcs_1.bcs
-                        .vector(bcs_1.bcs.u8())
-                        .serialize(casting_1.Casting.u8VectorFromString(lpCoinDescription))),
-                    tx.pure(bcs_1.bcs
-                        .vector(bcs_1.bcs.u8())
-                        .serialize(casting_1.Casting.u8VectorFromString(lpCoinIconUrl))),
-                    tx.pure(bcs_1.bcs
-                        .vector(bcs_1.bcs.u64())
-                        .serialize(coinsInfo.map((coin) => coin.weight))),
-                    tx.pure.u64(inputs.poolFlatness),
-                    tx.pure(bcs_1.bcs
-                        .vector(bcs_1.bcs.u64())
-                        .serialize(coinsInfo.map((coin) => coin.tradeFeeIn))),
-                    tx.pure(bcs_1.bcs
-                        .vector(bcs_1.bcs.u64())
-                        .serialize(coinsInfo.map((coin) => coin.tradeFeeOut))),
-                    tx.pure(bcs_1.bcs
-                        .vector(bcs_1.bcs.u64())
-                        .serialize(coinsInfo.map((coin) => coin.depositFee))),
-                    tx.pure(bcs_1.bcs
-                        .vector(bcs_1.bcs.u64())
-                        .serialize(coinsInfo.map((coin) => coin.withdrawFee))),
-                    ...coinsInfo.map((coin) => typeof coin.coinId === "string"
-                        ? tx.object(coin.coinId)
-                        : coin.coinId),
-                    tx.pure(bcs_1.bcs
-                        .option(bcs_1.bcs.vector(bcs_1.bcs.u8()))
-                        .serialize(decimals.includes(undefined)
-                        ? undefined
-                        : decimals)),
-                    tx.pure.bool(inputs.respectDecimals),
-                    tx.pure(bcs_1.bcs.option(bcs_1.bcs.u8()).serialize(inputs.forceLpDecimals)), // force_lp_decimals
-                ],
-            });
-        });
-        /**
-         * Returns the pool object ID for a given LP coin type transaction.
-         * @param inputs - An object containing the transaction block and LP coin type.
-         * @returns The pool object ID.
-         */
-        this.poolObjectIdForLpCoinTypeTx = (inputs) => {
-            const { tx, lpCoinType } = inputs;
-            return tx.moveCall({
-                target: utils_2.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)],
-            });
-        };
+        this.buildDaoFeePoolUpdateFeeBpsTx = utils_2.Helpers.transactions.createBuildTxFunc(this.daoFeePoolUpdateFeeBpsTx);
+        this.buildDaoFeePoolUpdateFeeRecipientTx = utils_2.Helpers.transactions.createBuildTxFunc(this.daoFeePoolUpdateFeeRecipientTx);
         // =========================================================================
         //  Inspections
         // =========================================================================
@@ -659,7 +876,6 @@ class PoolsApi {
         // =========================================================================
         //  Stats
         // =========================================================================
-        // TODO: use promise.all to execute some of this fetching in parallel
         /**
          * 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.
@@ -1091,14 +1307,22 @@ class PoolsApi {
         this.withdrawV2EventType = () => eventsApiHelpers_1.EventsApiHelpers.createEventType(this.addresses.pools.packages.eventsV2, PoolsApi.constants.moduleNames.events, PoolsApi.constants.eventNames.withdrawV2);
         const pools = Provider.addresses.pools;
         const referralVault = Provider.addresses.referralVault;
+        const daoFeePools = Provider.addresses.daoFeePools;
         if (!pools || !referralVault)
             throw new Error("not all required addresses have been set in provider");
         this.addresses = {
             pools,
             referralVault,
+            daoFeePools,
         };
         this.objectTypes = {
             pool: `${pools.packages.events}::pool::Pool`,
+            daoFeePool: daoFeePools
+                ? `${daoFeePools.packages.amm}::pool::DaoFeePool`
+                : undefined,
+            daoFeePoolOwnerCap: daoFeePools
+                ? `${daoFeePools.packages.amm}::pool::OwnerCap`
+                : undefined,
         };
         this.eventTypes = {
             trade: this.tradeEventType(),
@@ -1108,8 +1332,7 @@ class PoolsApi {
             depositV2: this.depositV2EventType(),
             withdrawV2: this.withdrawV2EventType(),
         };
-        this.moveErrors = {
-            [this.addresses.pools.packages.amm]: {
+        this.moveErrors = Object.assign({ [this.addresses.pools.packages.amm]: {
                 [PoolsApi.constants.moduleNames.pool]: {
                     /// A user provides a input that should be between 0 and `FIXED_ONE` but isn't.
                     0: "Flatness Not Normalized",
@@ -1140,69 +1363,69 @@ class PoolsApi {
                 [PoolsApi.constants.moduleNames.poolRegistry]: {
                     /// A user tries to create a Pool and the generic parameters of `create_pool_n_coins` were
                     ///  provided in nonlexicographical order.
-                    60: "NotSorted",
+                    60: "Not Sorted",
                     /// A user tries to create a Pool with exact parameters as an already active Pool.
-                    61: "DuplicatePool",
+                    61: "Duplicate Pool",
                     /// A user tries to upgrade the `PoolRegistry` to a value
-                    62: "InvalidUpgrade",
+                    62: "Invalid Upgrade",
                 },
                 [PoolsApi.constants.moduleNames.deposit]: {
                     /// A user attempts to perform a `deposit` with an older contract.
-                    20: "InvalidProtocolVersion",
+                    20: "Invalid Protocol Version",
                     /// A user attempts to perform `deposit-n-coins` on a Pool with a size `m` < `n`.
-                    21: "InvalidPoolSize",
+                    21: "Invalid Pool Size",
                     /// A user attempts to perform a deposit and provides a coin with a value of zero.
-                    22: "ZeroValue",
+                    22: "Zero Value",
                     // A user calls `deposit_n_coins` or `all_coin_deposit_n_coins` and provides the same generic
                     //  at least twice.
-                    23: "DuplicateTypes",
+                    23: "Duplicate Types",
                 },
                 [PoolsApi.constants.moduleNames.poolFactory]: {
                     /// A user attempts to create a pool on an older contract.
-                    10: "InvalidProtocolVersion",
+                    10: "Invalid Protocol Version",
                     /// A user attempts to create a Pool and provides a coin with a value of zero.
-                    11: "ZeroValue",
+                    11: "Zero Value",
                 },
                 [PoolsApi.constants.moduleNames.price]: {
                     /// A user attempts to query spot/oracle price using an old contract.
-                    10: "InvalidProtocolVersion",
+                    10: "Invalid Protocol Version",
                 },
                 [PoolsApi.constants.moduleNames.swap]: {
                     /// A user attempts to perform a `swap` with an older contract.
-                    40: "InvalidProtocolVersion",
+                    40: "Invalid Protocol Version",
                     /// A user attempts to perform `multi-swap-exact-in/out-n-to-m` on a Pool with a size
                     ///  `s` < `n` + `m`.
-                    41: "InvalidPoolSize",
+                    41: "Invalid Pool Size",
                     /// A user attempts to perform swap and providing provides a coin with a
                     ///  value of zero.
-                    42: "ZeroValue",
+                    42: "Zero Value",
                     /// A user attempts to perform a multi-coin withdraw and provides an `amounts_out`
                     ///  vector whose length does
-                    43: "BadVectorLength",
+                    43: "Bad Vector Length",
                     /// A user attempts to swap attempts to swap `Coin<CI>` for `amount_out` of `Coin<CO>`
                     ///  but its value is insufficient.
-                    44: "InsufficientCoinIn",
+                    44: "Insufficient Coin In",
                     // A user calls `multi_swap_exact_in_1_to_n` or `multi_swap_exact_out_1_to_n` and provides the same
                     //  generic at least twice.
-                    45: "DuplicateTypes",
+                    45: "Duplicate Types",
                     /// Something went wrong with the internal calculations
-                    46: "InternalError",
+                    46: "Internal Error",
                     /// An external app is trying to call authorized functions without permission.
-                    47: "NotAuthorized",
+                    47: "Not Authorized",
                 },
                 [PoolsApi.constants.moduleNames.withdraw]: {
                     /// A user attempts to perform a `withdraw` with an older contract.
-                    30: "InvalidProtocolVersion",
+                    30: "Invalid Protocol Version",
                     /// A user attempts to perform `withdraw-n-coins` on a Pool with a size `m` < `n`.
-                    31: "InvalidPoolSize",
+                    31: "Invalid PoolSize",
                     /// A user attempts to perform a withdraw and provides an LP coin with a value of zero.
-                    32: "ZeroValue",
+                    32: "Zero Value",
                     /// A user attempts to perform a multi-coin withdraw and provides an `amounts_out`
                     ///  vector whose length does
-                    33: "BadVectorLength",
+                    33: "Bad Vector Length",
                     // A user calls `withdraw_n_coins` or `all_coin_withdraw_n_coins` and provides the same generic
                     //  at least twice.
-                    34: "DuplicateTypes",
+                    34: "Duplicate Types",
                 },
                 [PoolsApi.constants.moduleNames.math]: {
                     // TODO: change error code in move
@@ -1212,25 +1435,35 @@ class PoolsApi {
                     51: "Slippage",
                     /// A user tries to perform a swap that would result in more than `MAX_SWAP_AMOUNT_IN` worth of
                     ///  one of the Pool's coins entering the Pool.
-                    52: "InvalidSwapAmountIn",
+                    52: "Invalid Swap Amount In",
                     /// A user tries to perform a swap that would result in more than `MAX_SWAP_AMOUNT_OUT` worth of
                     ///  one of the Pool's coins exiting the Pool.
-                    53: "InvalidSwapAmountOut",
+                    53: "Invalid Swap Amount Out",
                     /// A user tries to perform a `swap_exact_out` with a value for `amount_out` that equates to
                     ///  zero amount of `Coin<CI>`.
-                    54: "ZeroAmountIn",
+                    54: "Zero Amount In",
                     /// A user tries to perform a `swap_exact_in` with an amount of `Coin<CI>` that equates to
                     ///  zero amount of `Coin<CO>`.
-                    55: "ZeroAmountOut",
+                    55: "Zero Amount Out",
                     /// A user tries to deposit into a Pool with a deposit that is worth zero LP coins.
-                    56: "ZeroLpOut",
+                    56: "Zero Lp Out",
                     /// A user tries to invest with an lp ratio of 0
-                    57: "ZeroLpRatio",
+                    57: "Zero Lp Ratio",
                 },
                 [PoolsApi.constants.moduleNames.geometricMeanCalculations]: {},
                 [PoolsApi.constants.moduleNames.stableCalculations]: {},
-            },
-        };
+            } }, (this.addresses.daoFeePools
+            ? {
+                [this.addresses.daoFeePools.packages.amm]: {
+                    version: {
+                        /// A user tried to interact with an old contract.
+                        0: "Invalid Version",
+                        /// `init_package_version` has been called outside of this packages `init` function.
+                        1: "Version Object Already Created",
+                    },
+                },
+            }
+            : {}));
     }
     // =========================================================================
     //  Events