@bayswap/sdk/dist/cjs/modules/liquid.js

SDK for BaySwap smart contract

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.LiquidityModule = void 0;
const sui_js_1 = require("@mysten/sui.js");
const utils_1 = require("../utils");
class LiquidityModule {
    constructor(packageId, globalStorage, txBuilderConfig) {
        this._packageID = packageId;
        this._globalStorage = globalStorage;
        this._txBuilderConfig = txBuilderConfig;
    }
    buildAddLiquidityUnsignedTx(types, params) {
        const tx = new sui_js_1.TransactionBlock();
        if (params.coinX.length > 1 && types.coinX != sui_js_1.SUI_TYPE_ARG) {
            tx.mergeCoins(tx.object(params.coinX[0]), params.coinX.slice(1).map((id) => tx.object(id)));
        }
        if (params.coinY.length > 1 && types.coinY != sui_js_1.SUI_TYPE_ARG) {
            tx.mergeCoins(tx.object(params.coinY[0]), params.coinY.slice(1).map((id) => tx.object(id)));
        }
        const targetSplitX = types.coinX == sui_js_1.SUI_TYPE_ARG ? tx.gas : tx.object(params.coinX[0]);
        const [coinX] = tx.splitCoins(targetSplitX, [tx.pure(params.amtX)]);
        const targetSplitY = types.coinY == sui_js_1.SUI_TYPE_ARG ? tx.gas : tx.object(params.coinY[0]);
        const [coinY] = tx.splitCoins(targetSplitY, [tx.pure(params.amtY)]);
        tx.moveCall({
            target: `${this._packageID}::entry::add_liquidity`,
            typeArguments: [types.coinX, types.coinY, types.curve],
            arguments: [
                tx.object(this._globalStorage),
                coinX,
                tx.pure(params.minX),
                coinY,
                tx.pure(params.minY),
                tx.pure(params.minLP),
            ],
        });
        return tx;
    }
    buildUnsignedTxRegisterPoolAndAddLiquidity(types, params) {
        // sort order
        const sortedTypes = JSON.parse(JSON.stringify(types));
        const sortedParams = JSON.parse(JSON.stringify(params));
        if (!(0, utils_1.isCoinOrderSorted)(types.coinX, types.coinY)) {
            // swap order of types
            sortedTypes.coinX = types.coinY;
            sortedTypes.coinY = types.coinX;
            // swap order of params
            sortedParams.coinX = params.coinY;
            sortedParams.coinY = params.coinX;
            sortedParams.amtX = params.amtY;
            sortedParams.amtY = params.amtX;
            sortedParams.minX = params.minY;
            sortedParams.minY = params.minX;
        }
        const tx = new sui_js_1.TransactionBlock();
        if (sortedParams.coinX.length > 1 && sortedTypes.coinX != sui_js_1.SUI_TYPE_ARG) {
            tx.mergeCoins(tx.object(sortedParams.coinX[0]), sortedParams.coinX.slice(1).map((id) => tx.object(id)));
        }
        if (sortedParams.coinY.length > 1 && sortedTypes.coinY != sui_js_1.SUI_TYPE_ARG) {
            tx.mergeCoins(tx.object(sortedParams.coinY[0]), sortedParams.coinY.slice(1).map((id) => tx.object(id)));
        }
        const targetSplitX = sortedTypes.coinX == sui_js_1.SUI_TYPE_ARG
            ? tx.gas
            : tx.object(sortedParams.coinX[0]);
        const [coinX] = tx.splitCoins(targetSplitX, [tx.pure(sortedParams.amtX)]);
        const targetSplitY = sortedTypes.coinY == sui_js_1.SUI_TYPE_ARG
            ? tx.gas
            : tx.object(sortedParams.coinY[0]);
        const [coinY] = tx.splitCoins(targetSplitY, [tx.pure(sortedParams.amtY)]);
        tx.moveCall({
            target: `${this._packageID}::entry::register_pool_and_add_liquidity`,
            typeArguments: [sortedTypes.coinX, sortedTypes.coinY, sortedTypes.curve],
            arguments: [
                tx.object(this._globalStorage),
                coinX,
                tx.pure(sortedParams.minX),
                coinY,
                tx.pure(sortedParams.minY),
                tx.pure(params.minLP),
            ],
        });
        return tx;
    }
    // TODO: check type order
    buildUnsignedTxRegisterPool(types) {
        const tx = new sui_js_1.TransactionBlock();
        tx.moveCall({
            target: `${this._packageID}::entry::register_pool`,
            typeArguments: [types.coinX, types.coinY, types.curve],
            arguments: [tx.object(this._globalStorage)],
        });
        return tx;
    }
    buildUnsignedTxRemoveLiquidity(types, params) {
        const tx = new sui_js_1.TransactionBlock();
        if (params.lpCoins.length > 1) {
            tx.mergeCoins(tx.object(params.lpCoins[0]), params.lpCoins.slice(1).map((id) => tx.object(id)));
        }
        const [used] = tx.splitCoins(tx.object(params.lpCoins[0]), [
            tx.pure(params.burntAmt),
        ]);
        tx.moveCall({
            target: `${this._packageID}::entry::remove_liquidity`,
            typeArguments: [types.coinX, types.coinY, types.curve],
            arguments: [
                tx.object(this._globalStorage),
                used,
                tx.pure(params.minXOut),
                tx.pure(params.minYOut),
            ],
        });
        return tx;
    }
    buildTxZapIn(t, p) {
        const tx = new sui_js_1.TransactionBlock();
        if (p.coinIds.length > 1 && p.coinType != sui_js_1.SUI_TYPE_ARG) {
            tx.mergeCoins(tx.object(p.coinIds[0]), p.coinIds.slice(1).map((id) => tx.object(id)));
        }
        const targetSplit = p.coinType == sui_js_1.SUI_TYPE_ARG ? tx.gas : tx.object(p.coinIds[0]);
        const [used] = tx.splitCoins(targetSplit, [tx.pure(p.zapAmount)]);
        let funcName = 'zap_in_x';
        if (p.coinType == t.coinY) {
            funcName = 'zap_in_y';
        }
        tx.moveCall({
            target: `${this._packageID}::entry::${funcName}`,
            typeArguments: [t.coinX, t.coinY, t.curve],
            arguments: [tx.object(this._globalStorage), used, tx.pure(p.minLP)],
        });
        return tx;
    }
}
exports.LiquidityModule = LiquidityModule;
//# sourceMappingURL=liquid.js.map