@minswap/noodles-sdk 0.0.6 → 0.0.8

package/dist/index.cjs

@@ -0,0 +1,1596 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    TradeFeeOptions: ()=>types_TradeFeeOptions,
+    getMoveObjectContent: ()=>getMoveObjectContent,
+    MoonbagsCalculation: ()=>calculation_MoonbagsCalculation,
+    SevenKAggregator: ()=>_7k_SevenKAggregator,
+    SupportedBondingCurve: ()=>types_SupportedBondingCurve,
+    CLOCK_OBJECT_ID: ()=>CLOCK_OBJECT_ID,
+    BlastFunCustomCalculation: ()=>custom_calculation_BlastFunCustomCalculation,
+    BluefinTx: ()=>bluefin_BluefinTx,
+    Bps: ()=>package_Bps,
+    BlastFunCustomTransaction: ()=>custom_transaction_BlastFunCustomTransaction,
+    BASE_BPS: ()=>BASE_BPS,
+    MoonbagsConstants: ()=>constants_MoonbagsConstants,
+    getSuiClient: ()=>getSuiClient,
+    getSplitCoinForTx: ()=>getSplitCoinForTx,
+    SUI_FULL_TYPE: ()=>SUI_FULL_TYPE,
+    splitSuiCoinAfterFeeFromBuyTx: ()=>splitSuiCoinAfterFeeFromBuyTx,
+    BlastFunSDKTransaction: ()=>sdk_transaction_BlastFunSDKTransaction,
+    AstrosAggregator: ()=>astros_AstrosAggregator,
+    SUI_TYPE: ()=>SUI_TYPE,
+    AftermathAggregator: ()=>aftermath_AftermathAggregator,
+    getSplitCoinsAfterFee: ()=>getSplitCoinsAfterFee,
+    addGasFee: ()=>addGasFee,
+    MoonbagsPackage: ()=>package_MoonbagsPackage,
+    NATIVE_USDC_TOKEN_TYPE: ()=>NATIVE_USDC_TOKEN_TYPE,
+    USDC_TOKEN_TYPE: ()=>USDC_TOKEN_TYPE,
+    getAmountAfterFee: ()=>getAmountAfterFee,
+    SUI_METADATA_OBJECT_ID: ()=>SUI_METADATA_OBJECT_ID,
+    SupportedAggregator: ()=>common_SupportedAggregator,
+    splitSuiCoinAfterFeeFromSellTx: ()=>splitSuiCoinAfterFeeFromSellTx,
+    createCompatibleSuiClient: ()=>createCompatibleSuiClient,
+    BLUEFIN_PACKAGE_ID: ()=>BLUEFIN_PACKAGE_ID,
+    MoonbagsTransaction: ()=>transaction_MoonbagsTransaction,
+    BlastFunConstants: ()=>constants_BlastFunConstants,
+    CetusAggregator: ()=>cetus_CetusAggregator,
+    adaptSuiClient: ()=>adaptSuiClient,
+    getCoinObjectIdsByAmount: ()=>getCoinObjectIdsByAmount,
+    getMoveObject: ()=>getMoveObject,
+    FlowXAggregator: ()=>flowx_FlowXAggregator,
+    adaptTransaction: ()=>adaptTransaction,
+    MathUtils: ()=>package_MathUtils,
+    BlastFunSDKCalculation: ()=>sdk_calculation_BlastFunSDKCalculation,
+    BlastFunPackage: ()=>package_BlastFunPackage,
+    getMemezPumpSDK: ()=>getMemezPumpSDK,
+    getNeededGasFee: ()=>getNeededGasFee
+});
+const cjs_namespaceObject = require("@7kprotocol/sdk-ts/cjs");
+const transactions_namespaceObject = require("@mysten/sui/transactions");
+const external_bignumber_js_namespaceObject = require("bignumber.js");
+var external_bignumber_js_default = /*#__PURE__*/ __webpack_require__.n(external_bignumber_js_namespaceObject);
+class _7k_SevenKAggregator {
+    _config;
+    _suiClient;
+    constructor(config, suiClient){
+        this._config = config;
+        this._suiClient = suiClient;
+    }
+    async getTradeRoute({ coinInAmount, coinInType, coinOutType, tradeFee }) {
+        try {
+            if (this._config.sevenKApiKey) cjs_namespaceObject.Config.setApiKey(this._config.sevenKApiKey);
+            const tradeFeePercent = tradeFee ? tradeFee.tradeFeePercent : this._config.defaultTradeFee.tradeFeePercent;
+            return (0, cjs_namespaceObject.getQuote)({
+                tokenIn: coinInType,
+                tokenOut: coinOutType,
+                amountIn: coinInAmount.toString(),
+                commissionBps: 10000 * tradeFeePercent
+            });
+        } catch (_err) {
+            return null;
+        }
+    }
+    async getTransaction({ walletAddress, completeRoute, slippage, tradeFee }) {
+        let tradeFeePercent;
+        let tradeFeeRecipientAddress;
+        if (tradeFee) {
+            tradeFeePercent = tradeFee.tradeFeePercent;
+            tradeFeeRecipientAddress = tradeFee.tradeFeeRecipientAddress;
+        } else {
+            tradeFeePercent = this._config.defaultTradeFee.tradeFeePercent;
+            tradeFeeRecipientAddress = this._config.defaultTradeFee.tradeFeeRecipientAddress;
+        }
+        const transaction = await (0, cjs_namespaceObject.buildTx)({
+            quoteResponse: completeRoute,
+            slippage,
+            accountAddress: walletAddress,
+            commission: {
+                partner: tradeFeeRecipientAddress,
+                commissionBps: 10000 * tradeFeePercent
+            }
+        });
+        if (transaction.tx instanceof cjs_namespaceObject.BluefinXTx) {
+            const newTransaction = transactions_namespaceObject.Transaction.from(transaction.tx.txBytes);
+            return newTransaction.build({
+                client: this._suiClient
+            });
+        }
+        transaction.tx.setSender(walletAddress);
+        return transaction.tx.build({
+            client: this._suiClient
+        });
+    }
+}
+(function(SevenKAggregator) {
+    function toCommonTradeRoutes(tradeRouteResponse) {
+        const routes = [];
+        if (!tradeRouteResponse.routes || 0 === tradeRouteResponse.routes.length) return null;
+        for (const route of tradeRouteResponse.routes){
+            const paths = [];
+            const allTokenDecimal = {};
+            for (const path of route.hops){
+                for (const t of path.pool.allTokens)allTokenDecimal[t.address] = t.decimal;
+                const pathDecimalIn = allTokenDecimal[path.tokenIn] ?? 0;
+                const pathDecimalOut = allTokenDecimal[path.tokenOut] ?? 0;
+                const pathAmountIn = BigInt(new (external_bignumber_js_default())(path.tokenInAmount).multipliedBy(10 ** pathDecimalIn).toFixed(0, 3));
+                const pathAmountOut = BigInt(new (external_bignumber_js_default())(path.tokenOutAmount).multipliedBy(10 ** pathDecimalOut).toFixed(0, 3));
+                paths.push({
+                    poolAddress: path.poolId,
+                    coinIn: path.tokenIn,
+                    coinOut: path.tokenOut,
+                    amountIn: pathAmountIn,
+                    amountOut: pathAmountOut
+                });
+            }
+            if (0 === paths.length) continue;
+            const routeDecimalIn = allTokenDecimal[route.tokenIn] ?? 0;
+            const routeDecimalOut = allTokenDecimal[route.tokenOut] ?? 0;
+            const routeAmountIn = BigInt(new (external_bignumber_js_default())(route.tokenInAmount).multipliedBy(10 ** routeDecimalIn).toFixed(0, 3));
+            const routeAmountOut = BigInt(new (external_bignumber_js_default())(route.tokenOutAmount).multipliedBy(10 ** routeDecimalOut).toFixed(0, 3));
+            routes.push({
+                paths: paths,
+                coinIn: route.tokenIn,
+                coinOut: route.tokenOut,
+                amountIn: routeAmountIn,
+                amountOut: routeAmountOut
+            });
+        }
+        if (0 === routes.length) return null;
+        return {
+            coinIn: tradeRouteResponse.tokenIn,
+            coinOut: tradeRouteResponse.tokenOut,
+            amountIn: BigInt(tradeRouteResponse.swapAmountWithDecimal),
+            amountOut: BigInt(tradeRouteResponse.returnAmountWithDecimal),
+            routes: routes
+        };
+    }
+    SevenKAggregator.toCommonTradeRoutes = toCommonTradeRoutes;
+})(_7k_SevenKAggregator || (_7k_SevenKAggregator = {}));
+const external_aftermath_ts_sdk_namespaceObject = require("aftermath-ts-sdk");
+class aftermath_AftermathAggregator {
+    _config;
+    _aftermathClient;
+    _suiClient;
+    constructor(config, suiClient){
+        this._config = config;
+        this._suiClient = suiClient;
+    }
+    async aftermathClient() {
+        if (this._aftermathClient) return this._aftermathClient;
+        if (this._config.aftermathApiEndpoint) this._aftermathClient = new external_aftermath_ts_sdk_namespaceObject.Aftermath(this._config.aftermathApiEndpoint);
+        else this._aftermathClient = new external_aftermath_ts_sdk_namespaceObject.Aftermath("MAINNET");
+        await this._aftermathClient.init();
+        if (this._config.aftermathApiKey) {
+            const keypair = external_aftermath_ts_sdk_namespaceObject.Helpers.keypairFromPrivateKey(this._config.aftermathApiKey);
+            await this._aftermathClient.Auth().init({
+                async signMessageCallback ({ message }) {
+                    const { signature } = await keypair.signPersonalMessage(message);
+                    return {
+                        signature
+                    };
+                },
+                walletAddress: keypair.toSuiAddress()
+            });
+        }
+        return this._aftermathClient;
+    }
+    async getTradeRoute({ coinInAmount, coinInType, coinOutType, tradeFee }) {
+        let externalFee;
+        externalFee = tradeFee ? {
+            recipient: tradeFee.tradeFeeRecipientAddress,
+            feePercentage: tradeFee.tradeFeePercent
+        } : {
+            recipient: this._config.defaultTradeFee.tradeFeeRecipientAddress,
+            feePercentage: this._config.defaultTradeFee.tradeFeePercent
+        };
+        const client = await this.aftermathClient();
+        return client.Router().getCompleteTradeRouteGivenAmountIn({
+            coinInAmount,
+            coinInType,
+            coinOutType,
+            externalFee
+        });
+    }
+    async getTransaction({ completeRoute, walletAddress, slippage }) {
+        const client = await this.aftermathClient();
+        const transaction = await client.Router().getTransactionForCompleteTradeRoute({
+            completeRoute,
+            walletAddress,
+            slippage,
+            isSponsoredTx: false
+        });
+        transaction.setSender(walletAddress);
+        return transaction.build({
+            client: this._suiClient
+        });
+    }
+}
+(function(AftermathAggregator) {
+    function toCommonTradeRoutes(tradeRoute) {
+        if (0 === tradeRoute.routes.length) return null;
+        const routes = [];
+        for (const route of tradeRoute.routes){
+            const paths = [];
+            for (const path of route.paths)paths.push({
+                poolAddress: path.poolId,
+                coinIn: path.coinIn.type,
+                coinOut: path.coinOut.type,
+                amountIn: BigInt(path.coinIn.amount),
+                amountOut: BigInt(path.coinOut.amount)
+            });
+            if (0 !== paths.length) routes.push({
+                paths: paths,
+                coinIn: route.coinIn.type,
+                coinOut: route.coinOut.type,
+                amountIn: route.coinIn.amount,
+                amountOut: route.coinOut.amount
+            });
+        }
+        if (0 === routes.length) return null;
+        return {
+            coinIn: tradeRoute.coinIn.type,
+            coinOut: tradeRoute.coinOut.type,
+            amountIn: tradeRoute.coinIn.amount,
+            amountOut: tradeRoute.coinOut.amount,
+            routes: routes
+        };
+    }
+    AftermathAggregator.toCommonTradeRoutes = toCommonTradeRoutes;
+})(aftermath_AftermathAggregator || (aftermath_AftermathAggregator = {}));
+const astros_aggregator_sdk_namespaceObject = require("@naviprotocol/astros-aggregator-sdk");
+function isSuiCoin(coin) {
+    return "0x2::sui::SUI" === coin || "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI" === coin;
+}
+class astros_AstrosAggregator {
+    _config;
+    _suiClient;
+    constructor(config, suiClient){
+        this._config = config;
+        this._suiClient = suiClient;
+    }
+    async getTradeRoute({ coinInAmount, coinInType, coinOutType, tradeFee }) {
+        try {
+            let serviceFee;
+            serviceFee = tradeFee ? {
+                fee: tradeFee.tradeFeePercent,
+                receiverAddress: tradeFee.tradeFeeRecipientAddress
+            } : {
+                fee: this._config.defaultTradeFee.tradeFeePercent,
+                receiverAddress: this._config.defaultTradeFee.tradeFeeRecipientAddress
+            };
+            return (0, astros_aggregator_sdk_namespaceObject.getQuote)(coinInType, coinOutType, coinInAmount, this._config.astrosApiKey, {
+                byAmountIn: true,
+                serviceFee: serviceFee
+            });
+        } catch (_err) {
+            return null;
+        }
+    }
+    returnMergedCoins(txb, coins, amount) {
+        if (coins.length < 2) return txb.object(coins[0].coinObjectId);
+        let mergedBalance = 0;
+        const mergeList = [];
+        coins.sort((a, b)=>Number(b.balance) - Number(a.balance)).slice(1).forEach((coin)=>{
+            if (mergedBalance >= amount) return;
+            mergedBalance += Number(coin.balance);
+            mergeList.push(coin.coinObjectId);
+        });
+        const baseObj = coins[0].coinObjectId;
+        txb.mergeCoins(baseObj, mergeList);
+        return txb.object(baseObj);
+    }
+    async getTransaction({ completeRoute: quote, walletAddress, slippage, tradeFee }) {
+        let serviceFee;
+        serviceFee = tradeFee ? {
+            fee: tradeFee.tradeFeePercent,
+            receiverAddress: tradeFee.tradeFeeRecipientAddress
+        } : {
+            fee: this._config.defaultTradeFee.tradeFeePercent,
+            receiverAddress: this._config.defaultTradeFee.tradeFeeRecipientAddress
+        };
+        const minAmountOut = new (external_bignumber_js_default())(quote.amount_out).multipliedBy(1 - slippage - serviceFee.fee).toNumber();
+        const txb = new transactions_namespaceObject.Transaction();
+        let coinIn;
+        if (isSuiCoin(quote.from)) coinIn = txb.splitCoins(txb.gas, [
+            txb.pure.u64(quote.amount_in)
+        ]);
+        else {
+            const coins = await (0, astros_aggregator_sdk_namespaceObject.getCoins)(this._suiClient, walletAddress, quote.from);
+            const mergedCoins = this.returnMergedCoins(txb, coins.data, Number.parseFloat(quote.amount_in));
+            coinIn = txb.splitCoins(mergedCoins, [
+                txb.pure.u64(quote.amount_in)
+            ]);
+        }
+        const coinB = await (0, astros_aggregator_sdk_namespaceObject.buildSwapPTBFromQuote)(walletAddress, txb, minAmountOut, coinIn, quote, void 0, false, this._config.astrosApiKey, {
+            serviceFee: serviceFee
+        });
+        txb.transferObjects([
+            coinB
+        ], walletAddress);
+        txb.setSender(walletAddress);
+        return txb.build({
+            client: this._suiClient
+        });
+    }
+}
+(function(AstrosAggregator) {
+    function toCommonTradeRoutes(tradeRoute, coinInType, coinOutType) {
+        if (0 === tradeRoute.routes.length) return null;
+        const routes = [];
+        for (const route of tradeRoute.routes){
+            const paths = [];
+            for (const path of route.path)paths.push({
+                poolAddress: path.id,
+                coinIn: path.from,
+                coinOut: path.target,
+                amountIn: BigInt(path.amount_in),
+                amountOut: BigInt(path.amount_out)
+            });
+            if (0 !== paths.length) routes.push({
+                amountIn: BigInt(route.amount_in),
+                amountOut: BigInt(route.amount_out),
+                coinIn: paths[0].coinIn,
+                coinOut: paths[paths.length - 1].coinOut,
+                paths: paths
+            });
+        }
+        if (0 === routes.length) return null;
+        return {
+            coinIn: coinInType,
+            coinOut: coinOutType,
+            amountIn: BigInt(tradeRoute.amount_in),
+            amountOut: BigInt(tradeRoute.amount_out),
+            routes: routes
+        };
+    }
+    AstrosAggregator.toCommonTradeRoutes = toCommonTradeRoutes;
+})(astros_AstrosAggregator || (astros_AstrosAggregator = {}));
+const aggregator_sdk_namespaceObject = require("@cetusprotocol/aggregator-sdk");
+const external_bn_js_namespaceObject = require("bn.js");
+var external_bn_js_default = /*#__PURE__*/ __webpack_require__.n(external_bn_js_namespaceObject);
+(function(TradeFeeOptions) {
+    function equals(a, b) {
+        return a.tradeFeePercent === b.tradeFeePercent && a.tradeFeeRecipientAddress === b.tradeFeeRecipientAddress;
+    }
+    TradeFeeOptions.equals = equals;
+})(types_TradeFeeOptions || (types_TradeFeeOptions = {}));
+var types_TradeFeeOptions;
+class cetus_CetusAggregator {
+    _config;
+    _suiClient;
+    _cetusClient;
+    constructor(config, suiClient){
+        this._config = config;
+        this._suiClient = suiClient;
+    }
+    cetusClient(walletAddress, tradeFee) {
+        if (tradeFee && !types_TradeFeeOptions.equals(tradeFee, this._config.defaultTradeFee)) return new aggregator_sdk_namespaceObject.AggregatorClient({
+            client: this._suiClient,
+            overlayFeeReceiver: tradeFee.tradeFeeRecipientAddress,
+            overlayFeeRate: tradeFee.tradeFeePercent,
+            env: aggregator_sdk_namespaceObject.Env.Mainnet,
+            signer: walletAddress,
+            ...this._config.cetusApiKey && this._config.cetusApiEndpoint ? {
+                apiKey: this._config.cetusApiKey,
+                endpoint: this._config.cetusApiEndpoint
+            } : {},
+            partner: this._config.cetusPartnerId
+        });
+        if (this._cetusClient) return this._cetusClient;
+        this._cetusClient = new aggregator_sdk_namespaceObject.AggregatorClient({
+            client: this._suiClient,
+            overlayFeeReceiver: this._config.defaultTradeFee.tradeFeeRecipientAddress,
+            overlayFeeRate: this._config.defaultTradeFee.tradeFeePercent,
+            env: aggregator_sdk_namespaceObject.Env.Mainnet,
+            signer: walletAddress,
+            ...this._config.cetusApiKey && this._config.cetusApiEndpoint ? {
+                apiKey: this._config.cetusApiKey,
+                endpoint: this._config.cetusApiEndpoint
+            } : {},
+            partner: this._config.cetusPartnerId
+        });
+        return this._cetusClient;
+    }
+    async getTradeRoute({ coinInAmount, coinInType, coinOutType, tradeFee }) {
+        const client = this.cetusClient(void 0, tradeFee);
+        return client.findRouters({
+            from: coinInType,
+            target: coinOutType,
+            amount: new (external_bn_js_default())(coinInAmount.toString()),
+            byAmountIn: true
+        });
+    }
+    async getTransaction({ completeRoute: routers, walletAddress, slippage, tradeFee }) {
+        const txb = new transactions_namespaceObject.Transaction();
+        const client = this.cetusClient(walletAddress, tradeFee);
+        await client.fastRouterSwap({
+            router: routers,
+            txb,
+            slippage
+        });
+        await client.devInspectTransactionBlock(txb);
+        txb.setSender(walletAddress);
+        return txb.build({
+            client: this._suiClient
+        });
+    }
+}
+(function(CetusAggregator) {
+    function toCommonTradeRoutes(tradeRoute, coinInType, coinOutType) {
+        if (0 === tradeRoute.paths.length) return null;
+        const routes = [];
+        const allPaths = [];
+        let currentRoute = [];
+        for(let i = 0; i < tradeRoute.paths.length; i++){
+            const currentPath = tradeRoute.paths[i];
+            const tradePath = {
+                poolAddress: currentPath.id,
+                amountIn: BigInt(currentPath.amountIn),
+                amountOut: BigInt(currentPath.amountOut),
+                coinIn: currentPath.from,
+                coinOut: currentPath.target
+            };
+            currentRoute.push(tradePath);
+            if (i === tradeRoute.paths.length - 1) allPaths.push([
+                ...currentRoute
+            ]);
+            else {
+                const nextPath = tradeRoute.paths[i + 1];
+                if (currentPath.target !== nextPath.from) {
+                    allPaths.push([
+                        ...currentRoute
+                    ]);
+                    currentRoute = [];
+                }
+            }
+        }
+        for (const pathGroup of allPaths)if (0 !== pathGroup.length) routes.push({
+            amountIn: pathGroup[0].amountIn,
+            amountOut: pathGroup[pathGroup.length - 1].amountOut,
+            coinIn: pathGroup[0].coinIn,
+            coinOut: pathGroup[pathGroup.length - 1].coinOut,
+            paths: pathGroup
+        });
+        if (0 === routes.length) return null;
+        return {
+            coinIn: coinInType,
+            coinOut: coinOutType,
+            amountIn: BigInt(tradeRoute.amountIn.toString(10)),
+            amountOut: BigInt(tradeRoute.amountOut.toString(10)),
+            routes: routes
+        };
+    }
+    CetusAggregator.toCommonTradeRoutes = toCommonTradeRoutes;
+})(cetus_CetusAggregator || (cetus_CetusAggregator = {}));
+var common_SupportedAggregator = /*#__PURE__*/ function(SupportedAggregator) {
+    SupportedAggregator["ASTROS"] = "ASTROS";
+    SupportedAggregator["AFTERMATH"] = "AFTERMATH";
+    SupportedAggregator["SEVENK"] = "7K";
+    SupportedAggregator["CETUS"] = "CETUS";
+    SupportedAggregator["FLOWX"] = "FLOWX";
+    return SupportedAggregator;
+}({});
+const sdk_namespaceObject = require("@flowx-finance/sdk");
+function getInputPercent(percent) {
+    return 1e6 * percent;
+}
+class flowx_FlowXAggregator {
+    _config;
+    _suiClient;
+    constructor(config, suiClient){
+        this._config = config;
+        this._suiClient = suiClient;
+    }
+    getCommission(coinInType, tradeFee) {
+        let tradeFeePercent;
+        let tradeFeeRecipientAddress;
+        if (tradeFee) {
+            tradeFeePercent = tradeFee.tradeFeePercent;
+            tradeFeeRecipientAddress = tradeFee.tradeFeeRecipientAddress;
+        } else {
+            tradeFeePercent = this._config.defaultTradeFee.tradeFeePercent;
+            tradeFeeRecipientAddress = this._config.defaultTradeFee.tradeFeeRecipientAddress;
+        }
+        return new sdk_namespaceObject.Commission(tradeFeeRecipientAddress, new sdk_namespaceObject.Coin(coinInType), sdk_namespaceObject.CommissionType.PERCENTAGE, getInputPercent(tradeFeePercent), true);
+    }
+    async getTradeRoute({ coinInAmount, coinInType, coinOutType, tradeFee }) {
+        const quoter = new sdk_namespaceObject.AggregatorQuoter("mainnet", this._config.flowxApiKey);
+        try {
+            return quoter.getRoutes({
+                tokenIn: coinInType,
+                tokenOut: coinOutType,
+                amountIn: coinInAmount.toString(),
+                commission: this.getCommission(coinInType, tradeFee)
+            });
+        } catch (_err) {
+            return null;
+        }
+    }
+    async getTransaction({ walletAddress, completeRoute, slippage, tradeFee }) {
+        const tradeBuilder = new sdk_namespaceObject.TradeBuilder("mainnet", completeRoute.routes);
+        const result = tradeBuilder.sender(walletAddress).slippage(getInputPercent(slippage)).commission(this.getCommission(completeRoute.coinIn.coinType, tradeFee)).build();
+        return result.buildTransaction({
+            client: this._suiClient
+        }).then((tx)=>{
+            tx.setSender(walletAddress);
+            return tx.build({
+                client: this._suiClient
+            });
+        });
+    }
+}
+(function(FlowXAggregator) {
+    function toCommonTradeRoutes(tradeRoute) {
+        if (0 === tradeRoute.routes.length) return null;
+        const routes = [];
+        for (const route of tradeRoute.routes){
+            const paths = [];
+            for (const path of route.paths)paths.push({
+                amountIn: BigInt(path.amountIn.toString()),
+                amountOut: BigInt(path.amountOut.toString()),
+                coinIn: path.input.coinType,
+                coinOut: path.output.coinType,
+                poolAddress: path.pool.id
+            });
+            if (0 !== paths.length) routes.push({
+                amountIn: BigInt(route.amountIn.toString()),
+                amountOut: BigInt(route.amountOut.toString()),
+                coinIn: route.input.coinType,
+                coinOut: route.output.coinType,
+                paths: paths
+            });
+        }
+        if (0 === routes.length) return null;
+        return {
+            coinIn: tradeRoute.coinIn.coinType,
+            coinOut: tradeRoute.coinOut.coinType,
+            amountIn: BigInt(tradeRoute.amountIn.toString()),
+            amountOut: BigInt(tradeRoute.amountOut.toString()),
+            routes: routes
+        };
+    }
+    FlowXAggregator.toCommonTradeRoutes = toCommonTradeRoutes;
+})(flowx_FlowXAggregator || (flowx_FlowXAggregator = {}));
+(function(BlastFunConstants) {
+    BlastFunConstants.PACKAGE_ID_V4 = "0x7e6aa6e179466ab2814425a780b122575296d011119fa69d27f289f5a28814bd";
+    BlastFunConstants.MEMEZ_AV_OBJECT_ID = "0x2319e3e76dfad73d8f4684bdbf42be4f32d8ce4521dd61becc8261dc918d82c0";
+})(constants_BlastFunConstants || (constants_BlastFunConstants = {}));
+var constants_BlastFunConstants;
+const SUI_TYPE = "0x2::sui::SUI";
+const SUI_FULL_TYPE = "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI";
+const USDC_TOKEN_TYPE = "0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf::coin::COIN";
+const NATIVE_USDC_TOKEN_TYPE = "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC";
+const SUI_METADATA_OBJECT_ID = "0x9258181f5ceac8dbffb7030890243caed69a9599d2886d957a9cb7656af3bdb3";
+const CLOCK_OBJECT_ID = "0x0000000000000000000000000000000000000000000000000000000000000006";
+const client_namespaceObject = require("@mysten/sui/client");
+const config_suiClient = new client_namespaceObject.SuiClient({
+    url: (0, client_namespaceObject.getFullnodeUrl)("mainnet")
+});
+function getSuiClient() {
+    return config_suiClient;
+}
+const orderByKey = (array, key, sortBy)=>{
+    if (!array?.length) return;
+    let swapped;
+    do {
+        swapped = false;
+        for(let i = 0; i < array.length - 1; i++){
+            const a = BigInt(array[i][key]);
+            const b = BigInt(array[i + 1][key]);
+            if ("desc" === sortBy ? a < b : a > b) {
+                const temp = array[i];
+                array[i] = array[i + 1];
+                array[i + 1] = temp;
+                swapped = true;
+            }
+        }
+    }while (swapped);
+    return array;
+};
+const getCoinObjectIdsByAmount = async (address, amount, coinType)=>{
+    let coinBalances = [];
+    let hasNextPage = true;
+    let nextCursor;
+    while(hasNextPage)try {
+        const coins = await getSuiClient().getCoins({
+            owner: address,
+            coinType,
+            cursor: nextCursor
+        });
+        coinBalances = [
+            ...coinBalances,
+            ...coins.data
+        ];
+        hasNextPage = coins.hasNextPage;
+        nextCursor = coins.nextCursor;
+    } catch (error) {
+        console.error("Error fetching data:", error);
+        hasNextPage = false;
+    }
+    const coinObj = orderByKey(coinBalances.map((item)=>({
+            ...item,
+            balance: item.balance
+        })), "balance", "desc") ?? [];
+    let balance = "0";
+    const objectIds = [];
+    const objectCoins = [];
+    for (const coin of coinObj){
+        balance = (BigInt(coin.balance) + BigInt(balance)).toString(10);
+        objectIds.push(coin.coinObjectId);
+        objectCoins.push(coin);
+        if (BigInt(balance) >= BigInt(amount)) break;
+    }
+    return {
+        objectIds,
+        balance,
+        objectCoins
+    };
+};
+async function addGasFee(params) {
+    const { inheritTx, sender, feeAmount, suiInputAmount } = params;
+    const tx = inheritTx || new transactions_namespaceObject.Transaction();
+    tx.setGasBudget(feeAmount);
+    const { objectCoins } = await getCoinObjectIdsByAmount(sender, (BigInt(suiInputAmount || "0") + feeAmount).toString(), SUI_FULL_TYPE);
+    tx.setGasPayment(objectCoins.map((c)=>({
+            objectId: c.coinObjectId,
+            version: c.version,
+            digest: c.digest
+        })));
+    return tx;
+}
+const BLUEFIN_PACKAGE_ID = "0x62412b7268c35f3808336aee57a52836501f40b8ba5d936f8ad275e672befd04";
+(function(BluefinTx) {
+    function transferOrDestroyZeroCoin(tx, coinType, coin, address) {
+        tx.moveCall({
+            target: `${BLUEFIN_PACKAGE_ID}::utils::transfer_or_destroy`,
+            typeArguments: [
+                coinType
+            ],
+            arguments: [
+                coin,
+                tx.pure.address(address)
+            ]
+        });
+    }
+    BluefinTx.transferOrDestroyZeroCoin = transferOrDestroyZeroCoin;
+})(bluefin_BluefinTx || (bluefin_BluefinTx = {}));
+var bluefin_BluefinTx;
+const utils_namespaceObject = require("@mysten/sui/utils");
+async function getSplitCoinForTx(params) {
+    const { account, amount, splits, coinType, inheritTx, inspecTransaction, isSponsored = false } = params;
+    const tx = inheritTx ?? new transactions_namespaceObject.Transaction();
+    const { objectIds } = await getCoinObjectIdsByAmount(account, amount, coinType);
+    const coinObjectId = objectIds[0];
+    if ((0, utils_namespaceObject.normalizeStructTag)(coinType) === (0, utils_namespaceObject.normalizeStructTag)(SUI_FULL_TYPE) && !isSponsored) {
+        let coin;
+        if (inspecTransaction) {
+            if (objectIds.length > 1) tx.mergeCoins(tx.object(coinObjectId), objectIds.slice(1).map((item)=>tx.object(item)));
+            coin = tx.splitCoins(tx.object(coinObjectId), splits);
+        } else coin = tx.splitCoins(tx.gas, splits);
+        return {
+            tx,
+            coinData: coin
+        };
+    }
+    if (objectIds.length > 1) tx.mergeCoins(tx.object(coinObjectId), objectIds.slice(1).map((item)=>tx.object(item)));
+    const coinData = tx.splitCoins(tx.object(coinObjectId), splits);
+    return {
+        tx,
+        coinData
+    };
+}
+const BASE_BPS = 10000;
+function getSplitCoinsAfterFee(amount, fee) {
+    const amountNum = BigInt(amount);
+    const feeNum = BigInt(Number(fee) * BASE_BPS);
+    if (feeNum === BigInt(0)) return [
+        amountNum.toString()
+    ];
+    const feeAmount = amountNum * feeNum / BigInt(BASE_BPS);
+    const remainingAmount = amountNum - feeAmount;
+    return [
+        remainingAmount.toString(),
+        feeAmount.toString()
+    ];
+}
+function getAmountAfterFee(amount, fee) {
+    if (!fee || Number(fee) <= 0) return BigInt(amount);
+    const amountNum = BigInt(amount);
+    const feeNum = BigInt(Number(fee) * BASE_BPS);
+    if (feeNum === BigInt(0)) return amountNum;
+    const feeAmount = amountNum * feeNum / BigInt(BASE_BPS);
+    return amountNum - feeAmount;
+}
+async function getNeededGasFee(tx, sender, bufferPercent) {
+    const { effects: { gasUsed, status } } = await getSuiClient().devInspectTransactionBlock({
+        sender,
+        transactionBlock: tx
+    });
+    if ("success" !== status.status) throw new Error(`Transaction failed during dev inspect: ${status.error ?? ""}`);
+    const fee = BigInt(gasUsed.computationCost) + BigInt(gasUsed.storageCost) - BigInt(gasUsed.storageRebate);
+    const feeNum = BigInt(Number(bufferPercent) * BASE_BPS);
+    return fee * (BigInt(BASE_BPS) + feeNum) / BigInt(BASE_BPS);
+}
+const tiny_invariant_namespaceObject = require("@minswap/tiny-invariant");
+var tiny_invariant_default = /*#__PURE__*/ __webpack_require__.n(tiny_invariant_namespaceObject);
+async function getMoveObjectContent(objectId) {
+    const moveObject = await getMoveObject(objectId);
+    return moveObject.fields;
+}
+async function getMoveObject(objectId) {
+    const client = getSuiClient();
+    const objRes = await client.getObject({
+        id: objectId,
+        options: {
+            showContent: true
+        }
+    });
+    const content = objRes.data?.content;
+    tiny_invariant_default()(content, "Pool object not found or has no content");
+    tiny_invariant_default()("moveObject" === content.dataType, "Object is not a Move object");
+    return content;
+}
+function adaptSuiClient(client) {
+    return client;
+}
+function adaptTransaction(transaction) {
+    return transaction;
+}
+function createCompatibleSuiClient(client) {
+    return new Proxy(client, {
+        get (target, prop) {
+            const value = target[prop];
+            if ("function" == typeof value) return value.bind(target);
+            return value;
+        }
+    });
+}
+(function(MathUtils) {
+    (function(U64) {
+        function mulDivUp(a, b, c) {
+            let roundUp = BigInt(0);
+            if (a * b % c > BigInt(0)) roundUp = BigInt(1);
+            return a * b / c + roundUp;
+        }
+        U64.mulDivUp = mulDivUp;
+    })(MathUtils.U64 || (MathUtils.U64 = {}));
+})(package_MathUtils || (package_MathUtils = {}));
+(function(Bps) {
+    function calcUp(bps, amount) {
+        const bpsValue = BigInt(bps.pos0);
+        const denominator = BigInt(10000);
+        let roundUp;
+        roundUp = bpsValue * amount % denominator !== BigInt(0) ? BigInt(1) : BigInt(0);
+        return bpsValue * amount / denominator + roundUp;
+    }
+    Bps.calcUp = calcUp;
+    function sub(lhs, rhs) {
+        tiny_invariant_default()(BigInt(lhs.pos0) >= BigInt(rhs.pos0), "Bps underflow");
+        return {
+            pos0: (BigInt(lhs.pos0) - BigInt(rhs.pos0)).toString()
+        };
+    }
+    Bps.sub = sub;
+    function value(bps) {
+        return BigInt(bps.pos0);
+    }
+    Bps.value = value;
+    function new_(bps) {
+        return {
+            pos0: assertOverflow(bps).toString()
+        };
+    }
+    Bps.new_ = new_;
+    function assertOverflow(bps) {
+        tiny_invariant_default()(BigInt(bps) <= BigInt(10000), "Bps overflow");
+        return BigInt(bps);
+    }
+    Bps.assertOverflow = assertOverflow;
+})(package_Bps || (package_Bps = {}));
+(function(BlastFunPackage) {
+    (function(MemezFun) {
+        async function isSniperProtectedMemezFun(poolId) {
+            const memezFun = await getMoveObjectContent(poolId);
+            return memezFun.public_key.length > 0;
+        }
+        MemezFun.isSniperProtectedMemezFun = isSniperProtectedMemezFun;
+    })(BlastFunPackage.MemezFun || (BlastFunPackage.MemezFun = {}));
+    (function(MemezFees) {
+        function takeWithDiscount(fee, amount, discountBps) {
+            if ("Value" === fee.variant) {
+                const amountRequired = BigInt(fee.fields.pos0);
+                if (amountRequired === BigInt(0)) return BigInt(0);
+                if (amount >= amountRequired) return amountRequired;
+                throw new Error(`Insufficient amount to cover fee. Required: ${amountRequired}, provided: ${amount}`);
+            }
+            if ("Percentage" === fee.variant) {
+                const feeBps = fee.fields.pos0.fields;
+                if (BigInt(feeBps.pos0) === BigInt(0)) return BigInt(0);
+                const discountedFee = package_Bps.calcUp(package_Bps.sub(feeBps, discountBps), amount);
+                if (amount >= discountedFee) return discountedFee;
+                throw new Error(`Insufficient amount to cover fee. Required: ${discountedFee}, provided: ${amount}`);
+            }
+            throw new Error("Unknown fee variant");
+        }
+        MemezFees.takeWithDiscount = takeWithDiscount;
+        function calculateWithDiscount(fee, discountBps, amount) {
+            if ("Value" === fee.variant) return BigInt(fee.fields.pos0);
+            if ("Percentage" === fee.variant) {
+                const feeBps = fee.fields.pos0.fields;
+                return package_Bps.calcUp(package_Bps.sub(feeBps, discountBps), amount);
+            }
+            throw new Error("Unknown fee variant");
+        }
+        MemezFees.calculateWithDiscount = calculateWithDiscount;
+    })(BlastFunPackage.MemezFees || (BlastFunPackage.MemezFees = {}));
+    (function(MemezBurner) {
+        function calculate(burner, poolMemeBalance) {
+            const burnerFee = package_Bps.value(burner.fee.fields);
+            if (burnerFee === BigInt(0) || poolMemeBalance === BigInt(0)) return package_Bps.new_(0);
+            if (poolMemeBalance >= BigInt(burner.target_liquidity)) return package_Bps.new_(0);
+            const baseBps = BigInt(10000);
+            return package_Bps.new_(package_MathUtils.U64.mulDivUp(package_Bps.value(burner.fee.fields), package_MathUtils.U64.mulDivUp(poolMemeBalance, baseBps, BigInt(burner.target_liquidity)), baseBps));
+        }
+        MemezBurner.calculate = calculate;
+    })(BlastFunPackage.MemezBurner || (BlastFunPackage.MemezBurner = {}));
+    (function(MemezPump) {
+        async function getPumpState(memezFun) {
+            return await getMoveObjectContent(memezFun.inner_state);
+        }
+        MemezPump.getPumpState = getPumpState;
+        function pump(pumpState, quoteAmount) {
+            const constantProduct = pumpState.constant_product.fields;
+            const quoteSwapFee = BlastFunPackage.MemezFees.takeWithDiscount(constantProduct.quote_swap_fee, quoteAmount, constantProduct.quote_referrer_fee.fields);
+            const quoteAfterFee = quoteAmount - quoteSwapFee;
+            const memeBalance = BigInt(constantProduct.meme_balance);
+            const quoteBalance = BigInt(constantProduct.quote_balance);
+            const virtualLiquidity = BigInt(constantProduct.virtual_liquidity);
+            const memeOutExpected = memeBalance * quoteAfterFee / (virtualLiquidity + quoteBalance + quoteAfterFee);
+            const memeSwapFee = BlastFunPackage.MemezFees.takeWithDiscount(constantProduct.meme_swap_fee, memeOutExpected, constantProduct.meme_referrer_fee.fields);
+            return memeOutExpected - memeSwapFee;
+        }
+        MemezPump.pump = pump;
+        function dump(pumpState, memeAmount) {
+            const constantProduct = pumpState.constant_product.fields;
+            const memeSwapFee = BlastFunPackage.MemezFees.takeWithDiscount(constantProduct.meme_swap_fee, memeAmount, constantProduct.meme_referrer_fee.fields);
+            const inputAmount = memeAmount - memeSwapFee;
+            const memeBalance = BigInt(constantProduct.meme_balance);
+            const quoteBalance = BigInt(constantProduct.quote_balance);
+            const virtualLiquidity = BigInt(constantProduct.virtual_liquidity);
+            const burnBps = BlastFunPackage.MemezBurner.calculate(constantProduct.burner.fields, quoteBalance);
+            const burnAmount = package_Bps.calcUp(burnBps, inputAmount);
+            const inputAmountAfterFee = inputAmount - (package_Bps.value(burnBps) !== BigInt(0) ? burnAmount : BigInt(0));
+            let quoteOutBeforeFee = (virtualLiquidity + quoteBalance) * inputAmountAfterFee / (memeBalance + inputAmountAfterFee);
+            if (quoteOutBeforeFee > quoteBalance) quoteOutBeforeFee = quoteBalance;
+            const quoteSwapFee = BlastFunPackage.MemezFees.takeWithDiscount(constantProduct.quote_swap_fee, quoteOutBeforeFee, constantProduct.quote_referrer_fee.fields);
+            return quoteOutBeforeFee - quoteSwapFee;
+        }
+        MemezPump.dump = dump;
+    })(BlastFunPackage.MemezPump || (BlastFunPackage.MemezPump = {}));
+})(package_BlastFunPackage || (package_BlastFunPackage = {}));
+var package_MathUtils, package_Bps, package_BlastFunPackage;
+(function(BlastFunCustomCalculation) {
+    async function getCurveAmountAfterBuy(params) {
+        let { suiAmount, poolId, frontendFee } = params;
+        const memezFun = await getMoveObjectContent(poolId);
+        const pumpState = await package_BlastFunPackage.MemezPump.getPumpState(memezFun);
+        suiAmount = getAmountAfterFee(suiAmount, frontendFee);
+        return package_BlastFunPackage.MemezPump.pump(pumpState, suiAmount);
+    }
+    BlastFunCustomCalculation.getCurveAmountAfterBuy = getCurveAmountAfterBuy;
+    async function getSuiAmountAfterSell(params) {
+        const { curveAmount, poolId, frontendFee } = params;
+        const memezFun = await getMoveObjectContent(poolId);
+        const pumpState = await package_BlastFunPackage.MemezPump.getPumpState(memezFun);
+        const suiAmount = package_BlastFunPackage.MemezPump.dump(pumpState, curveAmount);
+        return getAmountAfterFee(suiAmount, frontendFee);
+    }
+    BlastFunCustomCalculation.getSuiAmountAfterSell = getSuiAmountAfterSell;
+})(custom_calculation_BlastFunCustomCalculation || (custom_calculation_BlastFunCustomCalculation = {}));
+var custom_calculation_BlastFunCustomCalculation;
+async function splitSuiCoinAfterFeeFromBuyTx(params) {
+    const { inputAmount, accountAddress, frontendFee, frontendFeeRecipient, extendTx, isSponsored } = params;
+    tiny_invariant_default()(params.inCoinType === SUI_FULL_TYPE || params.inCoinType === SUI_TYPE, "Input must be SUI");
+    const { tx: _tx, coinIn } = extendTx || {};
+    const splitSui = getSplitCoinsAfterFee(inputAmount, frontendFee || "0");
+    const tx = _tx || new transactions_namespaceObject.Transaction();
+    let coinData;
+    if (coinIn) {
+        coinData = tx.splitCoins(coinIn, splitSui);
+        bluefin_BluefinTx.transferOrDestroyZeroCoin(tx, SUI_FULL_TYPE, coinIn, accountAddress);
+    } else {
+        const { coinData: _data } = await getSplitCoinForTx({
+            account: accountAddress,
+            amount: inputAmount,
+            splits: splitSui,
+            coinType: SUI_FULL_TYPE,
+            inheritTx: tx,
+            isSponsored: isSponsored || false
+        });
+        coinData = _data;
+    }
+    let inputSuiCoin;
+    if (frontendFee && frontendFeeRecipient) {
+        const [_inputSuiCoin, frontendFeeCoin] = coinData;
+        inputSuiCoin = _inputSuiCoin;
+        tx.transferObjects([
+            frontendFeeCoin
+        ], tx.pure.address(frontendFeeRecipient || accountAddress));
+    } else [inputSuiCoin] = coinData;
+    return {
+        tx,
+        coinOut: inputSuiCoin
+    };
+}
+async function splitSuiCoinAfterFeeFromSellTx(tx, params, suiCoin) {
+    tiny_invariant_default()(params.outCoinType === SUI_FULL_TYPE || params.outCoinType === SUI_TYPE, "Output must be SUI");
+    if (Number(params.frontendFee || 0) <= 0) return {
+        tx,
+        coinOut: suiCoin
+    };
+    const suiCoinValue = tx.moveCall({
+        target: "0x2::coin::value",
+        typeArguments: [
+            params.outCoinType
+        ],
+        arguments: [
+            suiCoin
+        ]
+    });
+    const suiCoinFeeValue = tx.moveCall({
+        target: `${BLUEFIN_PACKAGE_ID}::math::mul_div_u64`,
+        typeArguments: [],
+        arguments: [
+            suiCoinValue,
+            tx.pure.u64(BigInt(Number(params.frontendFee || "0") * BASE_BPS)),
+            tx.pure.u64(BigInt(BASE_BPS))
+        ]
+    });
+    const suiCoinFee = tx.moveCall({
+        target: "0x2::coin::split",
+        typeArguments: [
+            params.outCoinType
+        ],
+        arguments: [
+            suiCoin,
+            suiCoinFeeValue
+        ]
+    });
+    tx.transferObjects([
+        suiCoinFee
+    ], tx.pure.address(params.frontendFeeRecipient || params.accountAddress));
+    return {
+        tx,
+        coinOut: suiCoin
+    };
+}
+var types_SupportedBondingCurve = /*#__PURE__*/ function(SupportedBondingCurve) {
+    SupportedBondingCurve["BLAST_FUN"] = "BLAST_FUN";
+    SupportedBondingCurve["MOONBAGS"] = "MOONBAGS";
+    return SupportedBondingCurve;
+}({});
+(function(BlastFunCustomTransaction) {
+    async function getAllowedVersions(_tx) {
+        const tx = _tx || new transactions_namespaceObject.Transaction();
+        return tx.moveCall({
+            target: `${constants_BlastFunConstants.PACKAGE_ID_V4}::memez_allowed_versions::get_allowed_versions`,
+            arguments: [
+                tx.object(constants_BlastFunConstants.MEMEZ_AV_OBJECT_ID)
+            ],
+            typeArguments: []
+        });
+    }
+    BlastFunCustomTransaction.getAllowedVersions = getAllowedVersions;
+    async function buildBuyTx(params) {
+        tiny_invariant_default()(!await package_BlastFunPackage.MemezFun.isSniperProtectedMemezFun(params.poolId), "This coin is a sniper protected coin, please use the Blast Fun website to trade it.");
+        const { tx, coinOut: suiCoinIn } = await splitSuiCoinAfterFeeFromBuyTx(params);
+        tiny_invariant_default()(suiCoinIn, "Coin out is required");
+        const curveCoin = tx.moveCall({
+            target: `${constants_BlastFunConstants.PACKAGE_ID_V4}::memez_pump::pump`,
+            typeArguments: [
+                params.outCoinType,
+                SUI_FULL_TYPE
+            ],
+            arguments: [
+                tx.object(params.poolId),
+                suiCoinIn,
+                tx.pure.vector("address", []),
+                tx.pure.vector("vector<u8>", []),
+                tx.pure.u64(params.minAmountOut),
+                await getAllowedVersions(tx)
+            ]
+        });
+        return {
+            tx,
+            coinOut: curveCoin
+        };
+    }
+    BlastFunCustomTransaction.buildBuyTx = buildBuyTx;
+    async function buildSellTx(params) {
+        tiny_invariant_default()(params.outCoinType === SUI_FULL_TYPE || params.outCoinType === SUI_TYPE, "Output must be SUI");
+        const memezFun = await getMoveObjectContent(params.poolId);
+        const { tx, coinData } = await getSplitCoinForTx({
+            amount: params.inputAmount,
+            coinType: params.inCoinType,
+            inheritTx: params.extendTx?.tx,
+            account: params.accountAddress,
+            splits: [
+                params.inputAmount
+            ]
+        });
+        const [inputCoin] = coinData;
+        const [suiCoin] = tx.moveCall({
+            target: `${constants_BlastFunConstants.PACKAGE_ID_V4}::memez_pump::dump`,
+            typeArguments: [
+                params.inCoinType,
+                params.outCoinType
+            ],
+            arguments: [
+                tx.object(params.poolId),
+                tx.object(memezFun.ipx_meme_coin_treasury),
+                inputCoin,
+                tx.pure.vector("address", []),
+                tx.pure.u64(params.minAmountOut),
+                await getAllowedVersions(tx)
+            ]
+        });
+        return await splitSuiCoinAfterFeeFromSellTx(tx, params, suiCoin);
+    }
+    BlastFunCustomTransaction.buildSellTx = buildSellTx;
+})(custom_transaction_BlastFunCustomTransaction || (custom_transaction_BlastFunCustomTransaction = {}));
+var custom_transaction_BlastFunCustomTransaction;
+const memez_fun_sdk_namespaceObject = require("@interest-protocol/memez-fun-sdk");
+const sui_core_sdk_namespaceObject = require("@interest-protocol/sui-core-sdk");
+const payload = {
+    network: sui_core_sdk_namespaceObject.Network.MAINNET,
+    fullNodeUrl: (0, client_namespaceObject.getFullnodeUrl)("mainnet")
+};
+const memezPump = new memez_fun_sdk_namespaceObject.MemezPumpSDK(payload);
+function getMemezPumpSDK() {
+    return memezPump;
+}
+(function(BlastFunSDKCalculation) {
+    async function getCurveAmountAfterBuy(params) {
+        let { suiAmount, poolId, frontendFee } = params;
+        suiAmount = getAmountAfterFee(suiAmount, frontendFee);
+        const { memeAmountOut } = await getMemezPumpSDK().quotePump({
+            pool: poolId,
+            amount: suiAmount
+        });
+        return memeAmountOut;
+    }
+    BlastFunSDKCalculation.getCurveAmountAfterBuy = getCurveAmountAfterBuy;
+    async function getSuiAmountAfterSell(params) {
+        const { curveAmount, poolId, frontendFee } = params;
+        const { quoteAmountOut } = await getMemezPumpSDK().quoteDump({
+            pool: poolId,
+            amount: curveAmount
+        });
+        return getAmountAfterFee(quoteAmountOut, frontendFee);
+    }
+    BlastFunSDKCalculation.getSuiAmountAfterSell = getSuiAmountAfterSell;
+})(sdk_calculation_BlastFunSDKCalculation || (sdk_calculation_BlastFunSDKCalculation = {}));
+var sdk_calculation_BlastFunSDKCalculation;
+(function(BlastFunSDKTransaction) {
+    async function buildBuyTx(params) {
+        const { tx, coinOut: suiCoinIn } = await splitSuiCoinAfterFeeFromBuyTx(params);
+        tiny_invariant_default()(suiCoinIn, "Coin out is required");
+        const { memeCoin, tx: tx2 } = await getMemezPumpSDK().pump({
+            pool: params.poolId,
+            quoteCoin: suiCoinIn,
+            minAmountOut: params.minAmountOut,
+            tx
+        });
+        return {
+            tx: tx2,
+            coinOut: memeCoin
+        };
+    }
+    BlastFunSDKTransaction.buildBuyTx = buildBuyTx;
+    async function buildSellTx(params) {
+        tiny_invariant_default()(params.outCoinType === SUI_FULL_TYPE || params.outCoinType === SUI_TYPE, "Output must be SUI");
+        const { tx, coinData } = await getSplitCoinForTx({
+            amount: params.inputAmount,
+            coinType: params.inCoinType,
+            inheritTx: params.extendTx?.tx,
+            account: params.accountAddress,
+            splits: [
+                params.inputAmount
+            ]
+        });
+        const [inputCoin] = coinData;
+        const { quoteCoin, tx: tx2 } = await getMemezPumpSDK().dump({
+            pool: params.poolId,
+            memeCoin: inputCoin,
+            tx,
+            minAmountOut: params.minAmountOut
+        });
+        return await splitSuiCoinAfterFeeFromSellTx(tx2, params, quoteCoin);
+    }
+    BlastFunSDKTransaction.buildSellTx = buildSellTx;
+    async function getBuyTransaction({ coinInAmount, coinInType, coinOutType, poolId, slippage, walletAddress, tradeFee }, suiClient) {
+        tiny_invariant_default()(coinInType === SUI_TYPE, "coinInType must be SUI for buy transaction");
+        tiny_invariant_default()(coinOutType !== coinInType, "coinOutType must be different from coinInType");
+        tiny_invariant_default()(slippage >= 0 && slippage < 1, "slippage must be between 0 (inclusive) and 1 (exclusive)");
+        tiny_invariant_default()(coinInAmount > 0, "coinInAmount must be greater than 0");
+        const inputAmount = coinInAmount;
+        const outputAmount = await sdk_calculation_BlastFunSDKCalculation.getCurveAmountAfterBuy({
+            poolId: poolId,
+            suiAmount: inputAmount,
+            frontendFee: tradeFee ? tradeFee.tradeFeePercent : void 0
+        });
+        const minAmountOut = BigInt(new (external_bignumber_js_default())(outputAmount.toString()).multipliedBy(1 - slippage).toFixed(0, 3));
+        let { tx, coinOut } = await buildBuyTx({
+            accountAddress: walletAddress,
+            inCoinType: coinInType,
+            outCoinType: coinOutType,
+            inputAmount: inputAmount.toString(),
+            minAmountOut: minAmountOut.toString(),
+            poolId: poolId,
+            frontendFee: tradeFee ? tradeFee.tradeFeePercent : void 0,
+            frontendFeeRecipient: tradeFee ? tradeFee.tradeFeeRecipientAddress : void 0,
+            extendTx: void 0,
+            isSponsored: false
+        });
+        tiny_invariant_default()(coinOut, "Coin out is required");
+        tx.transferObjects([
+            coinOut
+        ], tx.pure.address(walletAddress));
+        tx.setSender(walletAddress);
+        const feeAmount = await getNeededGasFee(tx, walletAddress, 0);
+        tx = await addGasFee({
+            inheritTx: tx,
+            sender: walletAddress,
+            feeAmount,
+            suiInputAmount: inputAmount
+        });
+        return tx.build({
+            client: suiClient
+        });
+    }
+    BlastFunSDKTransaction.getBuyTransaction = getBuyTransaction;
+    async function getSellTransaction({ coinInAmount, coinInType, coinOutType, poolId, slippage, walletAddress, tradeFee }, suiClient) {
+        tiny_invariant_default()(coinOutType === SUI_TYPE, "coinOutType must be SUI for sell transaction");
+        tiny_invariant_default()(coinOutType !== coinInType, "coinOutType must be different from coinInType");
+        tiny_invariant_default()(slippage >= 0 && slippage < 1, "slippage must be between 0 (inclusive) and 1 (exclusive)");
+        tiny_invariant_default()(coinInAmount > 0, "coinInAmount must be greater than 0");
+        const inputAmount = coinInAmount;
+        const outputAmount = await sdk_calculation_BlastFunSDKCalculation.getSuiAmountAfterSell({
+            poolId: poolId,
+            curveAmount: inputAmount,
+            frontendFee: tradeFee ? tradeFee.tradeFeePercent : void 0
+        });
+        const minAmountOut = BigInt(new (external_bignumber_js_default())(outputAmount.toString()).multipliedBy(1 - slippage).toFixed(0, 3));
+        let { tx, coinOut } = await buildSellTx({
+            accountAddress: walletAddress,
+            inCoinType: coinInType,
+            outCoinType: coinOutType,
+            inputAmount: inputAmount.toString(),
+            minAmountOut: minAmountOut.toString(),
+            poolId: poolId,
+            frontendFee: tradeFee ? tradeFee.tradeFeePercent : void 0,
+            frontendFeeRecipient: tradeFee ? tradeFee.tradeFeeRecipientAddress : void 0,
+            extendTx: void 0,
+            isSponsored: false
+        });
+        tiny_invariant_default()(coinOut, "Coin out is required");
+        tx.transferObjects([
+            coinOut
+        ], tx.pure.address(walletAddress));
+        tx.setSender(walletAddress);
+        const feeAmount = await getNeededGasFee(tx, walletAddress, 0);
+        tx = await addGasFee({
+            inheritTx: tx,
+            sender: walletAddress,
+            feeAmount
+        });
+        return tx.build({
+            client: suiClient
+        });
+    }
+    BlastFunSDKTransaction.getSellTransaction = getSellTransaction;
+})(sdk_transaction_BlastFunSDKTransaction || (sdk_transaction_BlastFunSDKTransaction = {}));
+var sdk_transaction_BlastFunSDKTransaction;
+(function(MoonbagsConstants) {
+    MoonbagsConstants.PACKAGE_ID = "0xb8df325010942634a4afb3db3901ee215546af43a4ec4af781e7213b0bba7290";
+    MoonbagsConstants.CONFIG_OBJECT_ID = "0x74aecf86067c6913960ba4925333aefd2b1f929cafca7e21fd55a8f244b70499";
+    MoonbagsConstants.LOCK_CONFIG_OBJECT_ID = "0xfb09822d9808980abd04c51321adb850701f5f55535c6206658ef4d910c3e9be";
+    MoonbagsConstants.BURN_MANAGER_OBJECT_ID = "0x1d94aa32518d0cb00f9de6ed60d450c9a2090761f326752ffad06b2e9404f845";
+    MoonbagsConstants.POOLS_OBJECT_ID = "0xf699e7f2276f5c9a75944b37a0c5b5d9ddfd2471bf6242483b03ab2887d198d0";
+    MoonbagsConstants.GLOBAL_CONFIG_OBJECT_ID = "0xdaa46292632c3c4d8f31f23ea0f9b36a28ff3677e9684980e4438403a67a3d8f";
+    MoonbagsConstants.FEE_DENOMINATOR = BigInt(10000);
+})(constants_MoonbagsConstants || (constants_MoonbagsConstants = {}));
+var constants_MoonbagsConstants;
+(function(MoonbagsPackage) {
+    (function(Curves) {
+        function calculateAddLiquidityCost(tokenIn, tokenReserve, tokenAmount) {
+            const availableReserve = tokenReserve - tokenAmount;
+            const numerator = tokenIn * tokenReserve;
+            const fraction = numerator / availableReserve;
+            return fraction - tokenIn;
+        }
+        Curves.calculateAddLiquidityCost = calculateAddLiquidityCost;
+        function calculateRemoveLiquidityReturn(tokenIn, tokenReserve, tokenRemoved) {
+            const denominator = tokenIn + tokenRemoved;
+            const fraction = tokenIn * tokenReserve / denominator;
+            return tokenReserve - fraction;
+        }
+        Curves.calculateRemoveLiquidityReturn = calculateRemoveLiquidityReturn;
+        function calculateTokenAmountReceived(tokenIn, tokenReserve, tokenOutReserve) {
+            const denominator = tokenIn + tokenOutReserve;
+            const fraction = tokenIn * tokenReserve / denominator;
+            return tokenReserve - fraction;
+        }
+        Curves.calculateTokenAmountReceived = calculateTokenAmountReceived;
+    })(MoonbagsPackage.Curves || (MoonbagsPackage.Curves = {}));
+    (function(Moonbags) {
+        async function getDynamicVirtualTokenReserves(poolId) {
+            const result = await getSuiClient().getDynamicFieldObject({
+                parentId: poolId,
+                name: {
+                    type: "vector<u8>",
+                    value: "virtual_token_reserves"
+                }
+            });
+            if (!result.data) return;
+            return BigInt(result.data.content.fields.value);
+        }
+        Moonbags.getDynamicVirtualTokenReserves = getDynamicVirtualTokenReserves;
+        function buyExactInReturnsWithLock(params) {
+            const { inputAmount, amountIn, pool, config, dynamicVirtualTokenReserves } = params;
+            const virtualSuiReserves = BigInt(pool.virtual_sui_reserves);
+            const virtualTokenReserves = BigInt(pool.virtual_token_reserves);
+            const remainTokenReserves = BigInt(pool.remain_token_reserves.fields.balance);
+            const expectedOut = MoonbagsPackage.Curves.calculateRemoveLiquidityReturn(virtualSuiReserves, virtualTokenReserves, amountIn);
+            const availableOut = virtualTokenReserves - (dynamicVirtualTokenReserves || remainTokenReserves);
+            let finalOut = expectedOut;
+            let usedSui = amountIn;
+            if (expectedOut > availableOut) {
+                finalOut = availableOut;
+                usedSui = MoonbagsPackage.Curves.calculateAddLiquidityCost(virtualSuiReserves, virtualTokenReserves, availableOut) + BigInt(1);
+            }
+            const feeAmount = usedSui * BigInt(config.platform_fee) / constants_MoonbagsConstants.FEE_DENOMINATOR;
+            tiny_invariant_default()(inputAmount >= usedSui + feeAmount, "Input amount is less than used SUI + fee");
+            return {
+                receivedCurve: finalOut,
+                receivedSui: inputAmount - usedSui - feeAmount
+            };
+        }
+        Moonbags.buyExactInReturnsWithLock = buyExactInReturnsWithLock;
+        function sellReturns(params) {
+            const { amountIn, pool, config } = params;
+            const virtualSuiReserves = BigInt(pool.virtual_sui_reserves);
+            const virtualTokenReserves = BigInt(pool.virtual_token_reserves);
+            const realSuiReserves = BigInt(pool.real_sui_reserves.fields.balance);
+            let rawSuiOut = MoonbagsPackage.Curves.calculateRemoveLiquidityReturn(virtualTokenReserves, virtualSuiReserves, amountIn);
+            if (rawSuiOut > realSuiReserves) rawSuiOut = realSuiReserves;
+            const feeAmount = rawSuiOut * BigInt(config.platform_fee) / constants_MoonbagsConstants.FEE_DENOMINATOR;
+            const finalSuiOut = rawSuiOut - feeAmount;
+            return {
+                receivedCurve: BigInt(0),
+                receivedSui: finalSuiOut
+            };
+        }
+        Moonbags.sellReturns = sellReturns;
+    })(MoonbagsPackage.Moonbags || (MoonbagsPackage.Moonbags = {}));
+})(package_MoonbagsPackage || (package_MoonbagsPackage = {}));
+var package_MoonbagsPackage;
+(function(MoonbagsCalculation) {
+    async function getCurveAmountAfterBuy(params) {
+        let { suiAmount, poolId, frontendFee } = params;
+        const [poolMoveStruct, configMoveStruct, dynamicVirtualTokenReserves] = await Promise.all([
+            getMoveObjectContent(poolId),
+            getMoveObjectContent(constants_MoonbagsConstants.CONFIG_OBJECT_ID),
+            package_MoonbagsPackage.Moonbags.getDynamicVirtualTokenReserves(poolId)
+        ]);
+        const pool = poolMoveStruct;
+        const config = configMoveStruct;
+        if (void 0 !== frontendFee) suiAmount = getAmountAfterFee(suiAmount, frontendFee);
+        const usedSui = suiAmount * constants_MoonbagsConstants.FEE_DENOMINATOR / (constants_MoonbagsConstants.FEE_DENOMINATOR + BigInt(config.platform_fee));
+        const { receivedCurve } = package_MoonbagsPackage.Moonbags.buyExactInReturnsWithLock({
+            inputAmount: suiAmount,
+            amountIn: usedSui,
+            pool,
+            config,
+            dynamicVirtualTokenReserves
+        });
+        return receivedCurve;
+    }
+    MoonbagsCalculation.getCurveAmountAfterBuy = getCurveAmountAfterBuy;
+    async function getSuiAmountAfterSell(params) {
+        const { curveAmount, poolId, frontendFee } = params;
+        const [poolMoveStruct, configMoveStruct] = await Promise.all([
+            getMoveObjectContent(poolId),
+            getMoveObjectContent(constants_MoonbagsConstants.CONFIG_OBJECT_ID)
+        ]);
+        const pool = poolMoveStruct;
+        const config = configMoveStruct;
+        const { receivedSui } = package_MoonbagsPackage.Moonbags.sellReturns({
+            amountIn: curveAmount,
+            pool,
+            config
+        });
+        if (void 0 !== frontendFee) return getAmountAfterFee(receivedSui, frontendFee);
+        return receivedSui;
+    }
+    MoonbagsCalculation.getSuiAmountAfterSell = getSuiAmountAfterSell;
+    async function getUsedSuiForTx(params) {
+        let { suiAmount, frontendFee } = params;
+        const configMoveStruct = await getMoveObjectContent(constants_MoonbagsConstants.CONFIG_OBJECT_ID);
+        const config = configMoveStruct;
+        if (void 0 !== frontendFee) suiAmount = getAmountAfterFee(suiAmount, frontendFee);
+        return suiAmount * constants_MoonbagsConstants.FEE_DENOMINATOR / (constants_MoonbagsConstants.FEE_DENOMINATOR + BigInt(config.platform_fee));
+    }
+    MoonbagsCalculation.getUsedSuiForTx = getUsedSuiForTx;
+})(calculation_MoonbagsCalculation || (calculation_MoonbagsCalculation = {}));
+var calculation_MoonbagsCalculation;
+(function(MoonbagsTransaction) {
+    async function buildBuyTx(params) {
+        const { tx, coinOut } = await splitSuiCoinAfterFeeFromBuyTx(params);
+        tiny_invariant_default()(coinOut, "Coin out is required");
+        const usedSui = await calculation_MoonbagsCalculation.getUsedSuiForTx({
+            suiAmount: BigInt(params.inputAmount),
+            frontendFee: params.frontendFee
+        });
+        const [suiCoin, curveCoin] = tx.moveCall({
+            target: `${constants_MoonbagsConstants.PACKAGE_ID}::moonbags::buy_exact_in_returns_with_lock`,
+            typeArguments: [
+                params.outCoinType
+            ],
+            arguments: [
+                tx.object(constants_MoonbagsConstants.CONFIG_OBJECT_ID),
+                tx.object(constants_MoonbagsConstants.LOCK_CONFIG_OBJECT_ID),
+                coinOut,
+                tx.pure.u64(usedSui),
+                tx.pure.u64(params.minAmountOut),
+                tx.object(constants_MoonbagsConstants.BURN_MANAGER_OBJECT_ID),
+                tx.object(constants_MoonbagsConstants.POOLS_OBJECT_ID),
+                tx.object(constants_MoonbagsConstants.GLOBAL_CONFIG_OBJECT_ID),
+                tx.object(SUI_METADATA_OBJECT_ID),
+                tx.object(CLOCK_OBJECT_ID)
+            ]
+        });
+        bluefin_BluefinTx.transferOrDestroyZeroCoin(tx, SUI_FULL_TYPE, suiCoin, params.accountAddress);
+        return {
+            tx,
+            coinOut: curveCoin
+        };
+    }
+    MoonbagsTransaction.buildBuyTx = buildBuyTx;
+    async function buildSellTx(params) {
+        tiny_invariant_default()(params.outCoinType === SUI_FULL_TYPE || params.outCoinType === SUI_TYPE, "Output must be SUI");
+        const { tx, coinData } = await getSplitCoinForTx({
+            amount: params.inputAmount,
+            coinType: params.inCoinType,
+            inheritTx: params.extendTx?.tx,
+            account: params.accountAddress,
+            splits: [
+                params.inputAmount
+            ]
+        });
+        const [inputCoin] = coinData;
+        const [suiCoin, curveCoin] = tx.moveCall({
+            target: `${constants_MoonbagsConstants.PACKAGE_ID}::moonbags::sell_returns`,
+            typeArguments: [
+                params.inCoinType
+            ],
+            arguments: [
+                tx.object(constants_MoonbagsConstants.CONFIG_OBJECT_ID),
+                inputCoin,
+                tx.pure.u64(params.minAmountOut),
+                tx.object(CLOCK_OBJECT_ID)
+            ]
+        });
+        bluefin_BluefinTx.transferOrDestroyZeroCoin(tx, params.inCoinType, curveCoin, params.accountAddress);
+        return await splitSuiCoinAfterFeeFromSellTx(tx, params, suiCoin);
+    }
+    MoonbagsTransaction.buildSellTx = buildSellTx;
+    async function getBuyTransaction({ coinInAmount, coinInType, coinOutType, poolId, slippage, walletAddress, tradeFee }, suiClient) {
+        tiny_invariant_default()(coinInType === SUI_TYPE, "coinInType must be SUI for buy transaction");
+        tiny_invariant_default()(coinOutType !== coinInType, "coinOutType must be different from coinInType");
+        tiny_invariant_default()(slippage >= 0 && slippage < 1, "slippage must be between 0 (inclusive) and 1 (exclusive)");
+        tiny_invariant_default()(coinInAmount > 0, "coinInAmount must be greater than 0");
+        const inputAmount = coinInAmount;
+        const outputAmount = await calculation_MoonbagsCalculation.getCurveAmountAfterBuy({
+            poolId: poolId,
+            suiAmount: inputAmount,
+            frontendFee: tradeFee ? tradeFee.tradeFeePercent : void 0
+        });
+        const minAmountOut = BigInt(new (external_bignumber_js_default())(outputAmount.toString()).multipliedBy(1 - slippage).toFixed(0, 3));
+        let { tx, coinOut } = await buildBuyTx({
+            accountAddress: walletAddress,
+            inCoinType: coinInType,
+            outCoinType: coinOutType,
+            inputAmount: inputAmount.toString(),
+            minAmountOut: minAmountOut.toString(),
+            poolId: poolId,
+            frontendFee: tradeFee ? tradeFee.tradeFeePercent : void 0,
+            frontendFeeRecipient: tradeFee ? tradeFee.tradeFeeRecipientAddress : void 0,
+            extendTx: void 0,
+            isSponsored: false
+        });
+        tiny_invariant_default()(coinOut, "Coin out is required");
+        tx.transferObjects([
+            coinOut
+        ], tx.pure.address(walletAddress));
+        tx.setSender(walletAddress);
+        const feeAmount = await getNeededGasFee(tx, walletAddress, 0);
+        tx = await addGasFee({
+            inheritTx: tx,
+            sender: walletAddress,
+            feeAmount,
+            suiInputAmount: inputAmount
+        });
+        return tx.build({
+            client: suiClient
+        });
+    }
+    MoonbagsTransaction.getBuyTransaction = getBuyTransaction;
+    async function getSellTransaction({ coinInAmount, coinInType, coinOutType, poolId, slippage, walletAddress, tradeFee }, suiClient) {
+        tiny_invariant_default()(coinOutType === SUI_TYPE, "coinOutType must be SUI for sell transaction");
+        tiny_invariant_default()(coinOutType !== coinInType, "coinOutType must be different from coinInType");
+        tiny_invariant_default()(slippage >= 0 && slippage < 1, "slippage must be between 0 (inclusive) and 1 (exclusive)");
+        tiny_invariant_default()(coinInAmount > 0, "coinInAmount must be greater than 0");
+        const inputAmount = coinInAmount;
+        const outputAmount = await calculation_MoonbagsCalculation.getSuiAmountAfterSell({
+            poolId: poolId,
+            curveAmount: inputAmount,
+            frontendFee: tradeFee ? tradeFee.tradeFeePercent : void 0
+        });
+        const minAmountOut = BigInt(new (external_bignumber_js_default())(outputAmount.toString()).multipliedBy(1 - slippage).toFixed(0, 3));
+        let { tx, coinOut } = await buildSellTx({
+            accountAddress: walletAddress,
+            inCoinType: coinInType,
+            outCoinType: coinOutType,
+            inputAmount: inputAmount.toString(),
+            minAmountOut: minAmountOut.toString(),
+            poolId: poolId,
+            frontendFee: tradeFee ? tradeFee.tradeFeePercent : void 0,
+            frontendFeeRecipient: tradeFee ? tradeFee.tradeFeeRecipientAddress : void 0,
+            extendTx: void 0,
+            isSponsored: false
+        });
+        tiny_invariant_default()(coinOut, "Coin out is required");
+        tx.transferObjects([
+            coinOut
+        ], tx.pure.address(walletAddress));
+        tx.setSender(walletAddress);
+        const feeAmount = await getNeededGasFee(tx, walletAddress, 0);
+        tx = await addGasFee({
+            inheritTx: tx,
+            sender: walletAddress,
+            feeAmount
+        });
+        return tx.build({
+            client: suiClient
+        });
+    }
+    MoonbagsTransaction.getSellTransaction = getSellTransaction;
+})(transaction_MoonbagsTransaction || (transaction_MoonbagsTransaction = {}));
+var transaction_MoonbagsTransaction;
+exports.AftermathAggregator = __webpack_exports__.AftermathAggregator;
+exports.AstrosAggregator = __webpack_exports__.AstrosAggregator;
+exports.BASE_BPS = __webpack_exports__.BASE_BPS;
+exports.BLUEFIN_PACKAGE_ID = __webpack_exports__.BLUEFIN_PACKAGE_ID;
+exports.BlastFunConstants = __webpack_exports__.BlastFunConstants;
+exports.BlastFunCustomCalculation = __webpack_exports__.BlastFunCustomCalculation;
+exports.BlastFunCustomTransaction = __webpack_exports__.BlastFunCustomTransaction;
+exports.BlastFunPackage = __webpack_exports__.BlastFunPackage;
+exports.BlastFunSDKCalculation = __webpack_exports__.BlastFunSDKCalculation;
+exports.BlastFunSDKTransaction = __webpack_exports__.BlastFunSDKTransaction;
+exports.BluefinTx = __webpack_exports__.BluefinTx;
+exports.Bps = __webpack_exports__.Bps;
+exports.CLOCK_OBJECT_ID = __webpack_exports__.CLOCK_OBJECT_ID;
+exports.CetusAggregator = __webpack_exports__.CetusAggregator;
+exports.FlowXAggregator = __webpack_exports__.FlowXAggregator;
+exports.MathUtils = __webpack_exports__.MathUtils;
+exports.MoonbagsCalculation = __webpack_exports__.MoonbagsCalculation;
+exports.MoonbagsConstants = __webpack_exports__.MoonbagsConstants;
+exports.MoonbagsPackage = __webpack_exports__.MoonbagsPackage;
+exports.MoonbagsTransaction = __webpack_exports__.MoonbagsTransaction;
+exports.NATIVE_USDC_TOKEN_TYPE = __webpack_exports__.NATIVE_USDC_TOKEN_TYPE;
+exports.SUI_FULL_TYPE = __webpack_exports__.SUI_FULL_TYPE;
+exports.SUI_METADATA_OBJECT_ID = __webpack_exports__.SUI_METADATA_OBJECT_ID;
+exports.SUI_TYPE = __webpack_exports__.SUI_TYPE;
+exports.SevenKAggregator = __webpack_exports__.SevenKAggregator;
+exports.SupportedAggregator = __webpack_exports__.SupportedAggregator;
+exports.SupportedBondingCurve = __webpack_exports__.SupportedBondingCurve;
+exports.TradeFeeOptions = __webpack_exports__.TradeFeeOptions;
+exports.USDC_TOKEN_TYPE = __webpack_exports__.USDC_TOKEN_TYPE;
+exports.adaptSuiClient = __webpack_exports__.adaptSuiClient;
+exports.adaptTransaction = __webpack_exports__.adaptTransaction;
+exports.addGasFee = __webpack_exports__.addGasFee;
+exports.createCompatibleSuiClient = __webpack_exports__.createCompatibleSuiClient;
+exports.getAmountAfterFee = __webpack_exports__.getAmountAfterFee;
+exports.getCoinObjectIdsByAmount = __webpack_exports__.getCoinObjectIdsByAmount;
+exports.getMemezPumpSDK = __webpack_exports__.getMemezPumpSDK;
+exports.getMoveObject = __webpack_exports__.getMoveObject;
+exports.getMoveObjectContent = __webpack_exports__.getMoveObjectContent;
+exports.getNeededGasFee = __webpack_exports__.getNeededGasFee;
+exports.getSplitCoinForTx = __webpack_exports__.getSplitCoinForTx;
+exports.getSplitCoinsAfterFee = __webpack_exports__.getSplitCoinsAfterFee;
+exports.getSuiClient = __webpack_exports__.getSuiClient;
+exports.splitSuiCoinAfterFeeFromBuyTx = __webpack_exports__.splitSuiCoinAfterFeeFromBuyTx;
+exports.splitSuiCoinAfterFeeFromSellTx = __webpack_exports__.splitSuiCoinAfterFeeFromSellTx;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "AftermathAggregator",
+    "AstrosAggregator",
+    "BASE_BPS",
+    "BLUEFIN_PACKAGE_ID",
+    "BlastFunConstants",
+    "BlastFunCustomCalculation",
+    "BlastFunCustomTransaction",
+    "BlastFunPackage",
+    "BlastFunSDKCalculation",
+    "BlastFunSDKTransaction",
+    "BluefinTx",
+    "Bps",
+    "CLOCK_OBJECT_ID",
+    "CetusAggregator",
+    "FlowXAggregator",
+    "MathUtils",
+    "MoonbagsCalculation",
+    "MoonbagsConstants",
+    "MoonbagsPackage",
+    "MoonbagsTransaction",
+    "NATIVE_USDC_TOKEN_TYPE",
+    "SUI_FULL_TYPE",
+    "SUI_METADATA_OBJECT_ID",
+    "SUI_TYPE",
+    "SevenKAggregator",
+    "SupportedAggregator",
+    "SupportedBondingCurve",
+    "TradeFeeOptions",
+    "USDC_TOKEN_TYPE",
+    "adaptSuiClient",
+    "adaptTransaction",
+    "addGasFee",
+    "createCompatibleSuiClient",
+    "getAmountAfterFee",
+    "getCoinObjectIdsByAmount",
+    "getMemezPumpSDK",
+    "getMoveObject",
+    "getMoveObjectContent",
+    "getNeededGasFee",
+    "getSplitCoinForTx",
+    "getSplitCoinsAfterFee",
+    "getSuiClient",
+    "splitSuiCoinAfterFeeFromBuyTx",
+    "splitSuiCoinAfterFeeFromSellTx"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});