aftermath-ts-sdk 0.0.162 → 0.0.164

package/dist/packages/external/cetus/cetusApi.js

@@ -10,52 +10,319 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CetusApi = void 0;
-const cetusApiHelpers_1 = require("./cetusApiHelpers");
+const sui_js_1 = require("@mysten/sui.js");
 const utils_1 = require("../../../general/utils");
 const __1 = require("../..");
+const bcs_1 = require("@mysten/bcs");
 class CetusApi {
-    /////////////////////////////////////////////////////////////////////
-    //// Constructor
-    /////////////////////////////////////////////////////////////////////
+    // =========================================================================
+    //  Constructor
+    // =========================================================================
     constructor(Provider) {
+        var _a;
         this.Provider = Provider;
-        /////////////////////////////////////////////////////////////////////
-        //// Public Methods
-        /////////////////////////////////////////////////////////////////////
-        /////////////////////////////////////////////////////////////////////
-        //// Objects
-        /////////////////////////////////////////////////////////////////////
+        // =========================================================================
+        //  Public Methods
+        // =========================================================================
+        // =========================================================================
+        //  Objects
+        // =========================================================================
         this.fetchAllPools = () => __awaiter(this, void 0, void 0, function* () {
-            const pools = yield this.Helpers.fetchAllPools();
-            return pools;
+            const poolsSimpleInfo = yield this.Provider.DynamicFields().fetchCastAllDynamicFieldsOfType({
+                parentObjectId: this.addresses.cetus.objects.poolsTable,
+                objectsFromObjectIds: (objectIds) => this.Provider.Objects().fetchCastObjectBatch({
+                    objectIds,
+                    objectFromSuiObjectResponse: CetusApi.poolFromSuiObjectResponse,
+                }),
+            });
+            const poolsMoreInfo = yield this.Provider.Objects().fetchCastObjectBatch({
+                objectIds: poolsSimpleInfo.map((poolInfo) => poolInfo.id),
+                objectFromSuiObjectResponse: (data) => {
+                    const fields = (0, sui_js_1.getObjectFields)(data);
+                    if (!fields)
+                        throw new Error("no fields found on cetus pool object");
+                    const liquidity = BigInt(fields.liquidity);
+                    const isPaused = fields.is_pause;
+                    return {
+                        liquidity,
+                        isPaused,
+                    };
+                },
+            });
+            const usablePools = poolsSimpleInfo.filter((_, index) => !poolsMoreInfo[index].isPaused &&
+                poolsMoreInfo[index].liquidity > BigInt(0));
+            return usablePools;
         });
-        this.fetchPoolsForTrade = (inputs) => {
-            return this.Helpers.fetchPoolsForTrade(inputs);
-        };
-        /////////////////////////////////////////////////////////////////////
-        //// Inspections
-        /////////////////////////////////////////////////////////////////////
+        this.fetchPoolsForTrade = (inputs) => __awaiter(this, void 0, void 0, function* () {
+            const possiblePools = yield this.fetchPoolsForCoinType({
+                coinType: inputs.coinOutType,
+            });
+            const [exactMatchPools, partialMatchPools] = utils_1.Helpers.bifilter(possiblePools, (pool) => CetusApi.isPoolForCoinTypes({
+                pool,
+                coinType1: inputs.coinInType,
+                coinType2: inputs.coinOutType,
+            }));
+            return {
+                exactMatchPools,
+                partialMatchPools,
+            };
+        });
+        // =========================================================================
+        //  Inspections
+        // =========================================================================
         this.fetchSupportedCoins = () => __awaiter(this, void 0, void 0, function* () {
-            const pools = yield this.Helpers.fetchAllPools();
+            const pools = yield this.fetchAllPools();
             const allCoins = pools.reduce((acc, pool) => [...acc, pool.coinTypeA, pool.coinTypeB], []);
             return utils_1.Helpers.uniqueArray(allCoins);
         });
         this.fetchTradeAmountOut = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            const tradeResult = yield this.Helpers.fetchCalcTradeResult(inputs);
+            const tradeResult = yield this.fetchCalcTradeResult(inputs);
             const coinOutAmountWithFees = __1.Pools.getAmountWithProtocolFees(Object.assign(Object.assign({}, inputs), { amount: tradeResult.amountOut }));
             return coinOutAmountWithFees;
         });
+        // =========================================================================
+        //  Inspections
+        // =========================================================================
+        this.fetchCalcTradeResult = (inputs) => __awaiter(this, void 0, void 0, function* () {
+            const tx = new sui_js_1.TransactionBlock();
+            tx.setSender(inputs.walletAddress);
+            this.calcTradeResultTx(Object.assign(Object.assign({ tx, poolObjectId: inputs.pool.id }, inputs.pool), inputs));
+            const resultBytes = yield this.Provider.Inspections().fetchFirstBytesFromTxOutput(tx);
+            sui_js_1.bcs.registerStructType("SwapStepResult", {
+                current_sqrt_price: bcs_1.BCS.U128,
+                target_sqrt_price: bcs_1.BCS.U128,
+                current_liquidity: bcs_1.BCS.U128,
+                amount_in: bcs_1.BCS.U64,
+                amount_out: bcs_1.BCS.U64,
+                fee_amount: bcs_1.BCS.U64,
+                remainer_amount: bcs_1.BCS.U64,
+            });
+            sui_js_1.bcs.registerStructType("CalculatedSwapResult", {
+                amount_in: bcs_1.BCS.U64,
+                amount_out: bcs_1.BCS.U64,
+                fee_amount: bcs_1.BCS.U64,
+                fee_rate: bcs_1.BCS.U64,
+                after_sqrt_price: bcs_1.BCS.U128,
+                is_exceed: bcs_1.BCS.BOOL,
+                step_results: "vector<SwapStepResult>",
+            });
+            const data = sui_js_1.bcs.de("CalculatedSwapResult", new Uint8Array(resultBytes));
+            return {
+                amountIn: BigInt(data.amount_in),
+                amountOut: BigInt(data.amount_out),
+                feeAmount: BigInt(data.fee_amount),
+                feeRate: BigInt(data.fee_rate),
+            };
+        });
+        // =========================================================================
+        //  Transaction Commands
+        // =========================================================================
+        this.tradeCoinAToCoinBTx = (inputs) => {
+            const { tx, coinInId, tradePotato, isFirstSwapForPath, isLastSwapForPath, } = inputs;
+            const isGivenAmountIn = "coinInAmount" in inputs;
+            return tx.moveCall({
+                target: utils_1.Helpers.transactions.createTxTarget(this.addresses.cetus.packages.wrapper, CetusApi.constants.moduleNames.wrapper, isGivenAmountIn ? "swap_a_to_b_by_a" : "swap_a_to_b_by_b"),
+                typeArguments: [inputs.coinInType, inputs.coinOutType],
+                arguments: [
+                    tx.object(this.addresses.cetus.objects.globalConfig),
+                    tx.object(inputs.poolObjectId),
+                    typeof coinInId === "string" ? tx.object(coinInId) : coinInId,
+                    ...(isGivenAmountIn
+                        ? []
+                        : [tx.pure(inputs.coinOutAmount, "u64")]),
+                    tx.pure(CetusApi.constants.inputs.minSqrtPriceLimit, "u128"),
+                    tx.object(__1.Sui.constants.addresses.suiClockId),
+                    // AF fees
+                    tx.object(this.addresses.pools.objects.protocolFeeVault),
+                    tx.object(this.addresses.pools.objects.treasury),
+                    tx.object(this.addresses.pools.objects.insuranceFund),
+                    tx.object(this.addresses.referralVault.objects.referralVault),
+                    // potato
+                    tradePotato,
+                    tx.pure(isFirstSwapForPath, "bool"),
+                    tx.pure(isLastSwapForPath, "bool"),
+                ],
+            });
+        };
+        this.tradeCoinBToCoinATx = (inputs) => {
+            const { tx, coinInId, tradePotato, isFirstSwapForPath, isLastSwapForPath, } = inputs;
+            const isGivenAmountIn = "coinInAmount" in inputs;
+            return tx.moveCall({
+                target: utils_1.Helpers.transactions.createTxTarget(this.addresses.cetus.packages.wrapper, CetusApi.constants.moduleNames.wrapper, isGivenAmountIn ? "swap_b_to_a_by_b" : "swap_b_to_a_by_a"),
+                typeArguments: [inputs.coinOutType, inputs.coinInType],
+                arguments: [
+                    tx.object(this.addresses.cetus.objects.globalConfig),
+                    tx.object(inputs.poolObjectId),
+                    typeof coinInId === "string" ? tx.object(coinInId) : coinInId,
+                    ...(isGivenAmountIn
+                        ? []
+                        : [tx.pure(inputs.coinOutAmount, "u64")]),
+                    tx.pure(CetusApi.constants.inputs.maxSqrtPriceLimit, "u128"),
+                    tx.object(__1.Sui.constants.addresses.suiClockId),
+                    // AF fees
+                    tx.object(this.addresses.pools.objects.protocolFeeVault),
+                    tx.object(this.addresses.pools.objects.treasury),
+                    tx.object(this.addresses.pools.objects.insuranceFund),
+                    tx.object(this.addresses.referralVault.objects.referralVault),
+                    // potato
+                    tradePotato,
+                    tx.pure(isFirstSwapForPath, "bool"),
+                    tx.pure(isLastSwapForPath, "bool"),
+                ],
+            });
+        };
+        this.tradeTx = (inputs) => {
+            const { coinInType, pool } = inputs;
+            const commandInputs = Object.assign(Object.assign({}, inputs), { poolObjectId: pool.id });
+            if (CetusApi.isCoinA({ pool, coinType: coinInType }))
+                return this.tradeCoinAToCoinBTx(commandInputs);
+            return this.tradeCoinBToCoinATx(commandInputs);
+        };
+        this.flashTradeTx = (inputs) => {
+            const { tx } = inputs;
+            const isCoinAToCoinB = inputs.coinInType === inputs.coinTypeA;
+            const sqrtPriceLimit = isCoinAToCoinB
+                ? CetusApi.constants.inputs.minSqrtPriceLimit
+                : CetusApi.constants.inputs.maxSqrtPriceLimit;
+            return tx.moveCall({
+                target: utils_1.Helpers.transactions.createTxTarget(this.addresses.cetus.packages.clmm, CetusApi.constants.moduleNames.pool, "flash_swap"),
+                typeArguments: [inputs.coinTypeA, inputs.coinTypeB],
+                arguments: [
+                    tx.object(inputs.poolObjectId),
+                    tx.pure(isCoinAToCoinB, "bool"),
+                    tx.pure("coinInAmount" in inputs, "bool"),
+                    tx.pure("coinInAmount" in inputs
+                        ? inputs.coinInAmount
+                        : inputs.coinOutAmount, "u64"),
+                    tx.pure(sqrtPriceLimit, "u128"), // sqrt_price_limit
+                ],
+            });
+        };
+        // =========================================================================
+        //  Transaction Inspection Commands
+        // =========================================================================
+        this.calcTradeResultTx = (inputs) => {
+            const { tx } = inputs;
+            return tx.moveCall({
+                target: utils_1.Helpers.transactions.createTxTarget(this.addresses.cetus.packages.clmm, CetusApi.constants.moduleNames.pool, "calculate_swap_result"),
+                typeArguments: [inputs.coinTypeA, inputs.coinTypeB],
+                arguments: [
+                    tx.object(inputs.poolObjectId),
+                    tx.pure(inputs.coinInType === inputs.coinTypeA, "bool"),
+                    tx.pure("coinInAmount" in inputs, "bool"),
+                    tx.pure("coinInAmount" in inputs
+                        ? inputs.coinInAmount
+                        : inputs.coinOutAmount, "u64"), // amount
+                ],
+            });
+        };
+        // =========================================================================
+        //  Transaction Builders
+        // =========================================================================
+        this.fetchBuildTradeTx = (inputs) => __awaiter(this, void 0, void 0, function* () {
+            const { walletAddress, coinInType, coinInAmount } = inputs;
+            const tx = new sui_js_1.TransactionBlock();
+            tx.setSender(walletAddress);
+            const coinInId = yield this.Provider.Coin().fetchCoinWithAmountTx({
+                tx,
+                walletAddress,
+                coinType: coinInType,
+                coinAmount: coinInAmount,
+            });
+            this.tradeTx(Object.assign(Object.assign({ tx }, inputs), { coinInId }));
+            return tx;
+        });
+        // =========================================================================
+        //  Helpers
+        // =========================================================================
         this.otherCoinInPool = (inputs) => {
-            return cetusApiHelpers_1.CetusApiHelpers.otherCoinInPool(inputs);
+            return CetusApi.isCoinA(inputs)
+                ? inputs.pool.coinTypeB
+                : inputs.pool.coinTypeA;
         };
-        /////////////////////////////////////////////////////////////////////
-        //// Transactions
-        /////////////////////////////////////////////////////////////////////
-        this.fetchTradeTx = (inputs) => {
-            return this.Provider.Transactions().fetchSetGasBudgetAndSerializeTransaction(this.Helpers.fetchBuildTradeTx(inputs));
+        // =========================================================================
+        //  Private Methods
+        // =========================================================================
+        // =========================================================================
+        //  Objects
+        // =========================================================================
+        this.fetchPoolForCoinTypes = (inputs) => __awaiter(this, void 0, void 0, function* () {
+            const allPools = yield this.fetchAllPools();
+            // NOTE: will there ever be more than 1 valid pool (is this unsafe ?)
+            const foundPool = allPools.find((pool) => CetusApi.isPoolForCoinTypes(Object.assign({ pool }, inputs)));
+            if (!foundPool)
+                throw new Error("no cetus pools found for given coin types");
+            return foundPool;
+        });
+        this.fetchPoolsForCoinType = (inputs) => __awaiter(this, void 0, void 0, function* () {
+            const allPools = yield this.fetchAllPools();
+            const foundPools = allPools.filter((pool) => CetusApi.isPoolForCoinType(Object.assign({ pool }, inputs)));
+            return foundPools;
+        });
+        const cetus = (_a = this.Provider.addresses.router) === null || _a === void 0 ? void 0 : _a.cetus;
+        const pools = this.Provider.addresses.pools;
+        const referralVault = this.Provider.addresses.referralVault;
+        if (!cetus || !pools || !referralVault)
+            throw new Error("not all required addresses have been set in provider");
+        this.addresses = {
+            cetus,
+            pools,
+            referralVault,
+        };
+        this.objectTypes = {
+            pool: `${cetus.packages.clmm}::pool::Pool`,
         };
-        this.Provider = Provider;
-        this.Helpers = new cetusApiHelpers_1.CetusApiHelpers(Provider);
     }
 }
 exports.CetusApi = CetusApi;
+// =========================================================================
+//  Constants
+// =========================================================================
+CetusApi.constants = {
+    moduleNames: {
+        poolScript: "pool_script",
+        pool: "pool",
+        wrapper: "cetus",
+    },
+    inputs: {
+        minSqrtPriceLimit: BigInt("4295048016"),
+        maxSqrtPriceLimit: BigInt("79226673515401279992447579055"),
+    },
+};
+// =========================================================================
+//  Private Static Methods
+// =========================================================================
+// =========================================================================
+//  Casting
+// =========================================================================
+CetusApi.poolFromSuiObjectResponse = (data) => {
+    var _a;
+    const content = (_a = data.data) === null || _a === void 0 ? void 0 : _a.content;
+    if ((content === null || content === void 0 ? void 0 : content.dataType) !== "moveObject")
+        throw new Error("sui object response is not an object");
+    const fields = content.fields.value.fields.value.fields;
+    return {
+        coinTypeA: "0x" + fields.coin_type_a.fields.name,
+        coinTypeB: "0x" + fields.coin_type_b.fields.name,
+        id: fields.pool_id,
+    };
+};
+// =========================================================================
+//  Helpers
+// =========================================================================
+CetusApi.isPoolForCoinTypes = (inputs) => {
+    const { pool, coinType1, coinType2 } = inputs;
+    return ((pool.coinTypeA === utils_1.Helpers.addLeadingZeroesToType(coinType1) &&
+        pool.coinTypeB === utils_1.Helpers.addLeadingZeroesToType(coinType2)) ||
+        (pool.coinTypeA === utils_1.Helpers.addLeadingZeroesToType(coinType2) &&
+            pool.coinTypeB === utils_1.Helpers.addLeadingZeroesToType(coinType1)));
+};
+CetusApi.isPoolForCoinType = (inputs) => {
+    const { pool, coinType } = inputs;
+    return (pool.coinTypeA === utils_1.Helpers.addLeadingZeroesToType(coinType) ||
+        pool.coinTypeB === utils_1.Helpers.addLeadingZeroesToType(coinType));
+};
+CetusApi.isCoinA = (inputs) => {
+    const { coinType, pool } = inputs;
+    return utils_1.Helpers.addLeadingZeroesToType(coinType) === pool.coinTypeA;
+};