@alphafi/alphafi-sdk 0.0.66 → 0.0.68

package/dist/esm/transactions/zapDeposit.js

@@ -8,245 +8,270 @@ import { SevenKGateway } from "./7k.js";
 import { getConf } from "../common/constants.js";
 import { getReceipts } from "../sui-sdk/functions/getReceipts.js";
 import { getLatestPrices } from "../utils/prices.js";
-import { mintTx, redeemTx, stSuiExchangeRate } from "@alphafi/stsui-sdk";
+import { mintTx, redeemTx, stSuiExchangeRate, getConf as getStSuiConf, } from "@alphafi/stsui-sdk";
 import { Decimal } from "decimal.js";
-export async function zapDepositTxb(inputCoinName, inputCoinAmount, poolName, slippage, // 0.01 --> 1%, 0.001 --> 0.1%
-options) {
-    let txb = new Transaction();
-    const suiClient = getSuiClient();
-    const address = options.address;
-    const coinTypeA = doubleAssetPoolCoinMap[poolName].coin1;
-    const coinTypeB = doubleAssetPoolCoinMap[poolName].coin2;
-    const swapObjectA = coinsList[coinTypeA];
-    const swapObjectB = coinsList[coinTypeB];
-    const inputObject = coinsList[inputCoinName];
-    const swapGateway = new SevenKGateway();
-    let coin1, coin2;
-    let amountA, amountB;
-    const amounts = await getAmounts(poolName, true, "100000001");
-    if (!amounts) {
-        console.error("Error fetching amounts for zap");
+// Case 1: When the first amount is zero
+async function handleFirstAmountZero(params, coinDetails, suiClient) {
+    params.amountA = "0";
+    params.coinA = params.txb.moveCall({
+        target: "0x2::coin::zero",
+        typeArguments: [coinDetails.swapObjectA.type],
+        arguments: [],
+    });
+    if (coinDetails.inputObject.type === coinDetails.swapObjectB.type) {
+        params.amountB = coinDetails.inputCoinAmount.toString();
+        const res = await splitFromExisting(coinDetails.swapObjectB.name, params.amountB ?? "0", params.txb, suiClient, coinDetails.address);
+        params.txb = res.tx;
+        params.coinB = res.coinOut;
+    }
+    else {
+        const swapOptionsI2B = {
+            pair: { coinA: coinDetails.inputObject, coinB: coinDetails.swapObjectB },
+            senderAddress: coinDetails.address,
+            inAmount: new BN(coinDetails.inputCoinAmount),
+            slippage: coinDetails.slippage,
+        };
+        const result = await zapSwap(swapOptionsI2B, params.txb, coinDetails.poolName);
+        if (result) {
+            params.amountB = result.amountOut;
+            params.txb = result.tx;
+            if (result.coinOut)
+                params.coinB = result.coinOut;
+        }
+    }
+    return params;
+}
+// Case 2: When the second amount is zero
+async function handleSecondAmountZero(params, coinDetails, suiClient) {
+    params.amountB = "0";
+    params.coinB = params.txb.moveCall({
+        target: "0x2::coin::zero",
+        typeArguments: [coinDetails.swapObjectB.type],
+        arguments: [],
+    });
+    if (coinDetails.inputObject.type === coinDetails.swapObjectA.type) {
+        params.amountA = coinDetails.inputCoinAmount.toString();
+        const res = await splitFromExisting(coinDetails.swapObjectA.name, params.amountA, params.txb, suiClient, coinDetails.address);
+        params.txb = res.tx;
+        params.coinA = res.coinOut;
+    }
+    else {
+        const swapOptionsI2A = {
+            pair: { coinA: coinDetails.inputObject, coinB: coinDetails.swapObjectA },
+            senderAddress: coinDetails.address,
+            inAmount: new BN(coinDetails.inputCoinAmount),
+            slippage: coinDetails.slippage,
+        };
+        const result = await zapSwap(swapOptionsI2A, params.txb, coinDetails.poolName);
+        if (result) {
+            params.amountA = result.amountOut;
+            params.txb = result.tx;
+            if (result.coinOut)
+                params.coinA = result.coinOut;
+        }
+    }
+    return params;
+}
+// Case 3: When both amounts are nonzero
+async function handleNonZeroAmounts(params, coinDetails, amounts, suiClient) {
+    const amount1 = Number(amounts[0]);
+    const amount2 = Number(amounts[1]);
+    const swapOptions = {
+        pair: { coinA: coinDetails.swapObjectA, coinB: coinDetails.swapObjectB },
+        senderAddress: coinDetails.address,
+        inAmount: new BN(amount1),
+        slippage: coinDetails.slippage,
+    };
+    const ratioQuote = await zapGetQuote(coinDetails.swapGateway, swapOptions, coinDetails.poolName);
+    if (ratioQuote === undefined) {
+        console.error("Error fetching ratioQuote for Zap");
         return undefined;
     }
-    if (Number(amounts[0]) === 0) {
-        amountA = "0";
-        coin1 = txb.moveCall({
-            target: "0x2::coin::zero",
-            typeArguments: [swapObjectA.type],
-            arguments: [],
-        });
-        if (inputCoinName === coinTypeB) {
-            amountB = inputCoinAmount.toString();
-            const res = await splitFromExisting(coinTypeB, amountB, txb, suiClient, address);
-            txb = res.tx;
-            coin2 = res.coinOut;
+    const amount1InCoinType2 = Number(ratioQuote);
+    const totalAmount = amount2 + amount1InCoinType2;
+    const inputAmountToType1 = Math.floor((coinDetails.inputCoinAmount * amount1InCoinType2) / totalAmount);
+    const inputAmountToType2 = Math.floor((coinDetails.inputCoinAmount * amount2) / totalAmount);
+    const swapOptionsI2A = {
+        pair: { coinA: coinDetails.inputObject, coinB: coinDetails.swapObjectA },
+        senderAddress: coinDetails.address,
+        inAmount: new BN(inputAmountToType1),
+        slippage: coinDetails.slippage,
+    };
+    const swapOptionsI2B = {
+        pair: { coinA: coinDetails.inputObject, coinB: coinDetails.swapObjectB },
+        senderAddress: coinDetails.address,
+        inAmount: new BN(inputAmountToType2),
+        slippage: coinDetails.slippage,
+    };
+    let swapResult;
+    if (coinDetails.inputObject.type === coinDetails.swapObjectA.type) {
+        swapResult = await zapSwap(swapOptionsI2B, params.txb, coinDetails.poolName);
+        if (swapResult) {
+            params.amountB = swapResult.amountOut;
+            params.txb = swapResult.tx;
+            if (swapResult.coinOut)
+                params.coinB = swapResult.coinOut;
+        }
+        params.amountA = inputAmountToType1.toString();
+        if (swapResult && swapResult.remainingLSTCoin) {
+            params.coinA = swapResult.remainingLSTCoin;
         }
         else {
-            const swapOptionsI2B = {
-                pair: {
-                    coinA: inputObject,
-                    coinB: swapObjectB,
-                },
-                senderAddress: address,
-                inAmount: new BN(inputCoinAmount),
-                slippage: slippage,
-            };
-            const result = await zapSwap(swapOptionsI2B, txb, poolName);
-            if (result) {
-                amountB = result.amountOut;
-                txb = result.tx;
-                if (result.coinOut) {
-                    coin2 = result.coinOut;
-                }
-            }
+            const res = await splitFromExisting(coinDetails.swapObjectA.name, params.amountA, params.txb, suiClient, coinDetails.address);
+            params.txb = res.tx;
+            params.coinA = res.coinOut;
         }
     }
-    else if (Number(amounts[1]) === 0) {
-        amountB = "0";
-        coin2 = txb.moveCall({
-            target: "0x2::coin::zero",
-            typeArguments: [swapObjectB.type],
-            arguments: [],
-        });
-        if (inputCoinName === coinTypeA) {
-            amountA = inputCoinAmount.toString();
-            const res = await splitFromExisting(coinTypeA, amountA, txb, suiClient, address);
-            txb = res.tx;
-            coin1 = res.coinOut;
+    else if (coinDetails.inputObject.type === coinDetails.swapObjectB.type) {
+        swapResult = await zapSwap(swapOptionsI2A, params.txb, coinDetails.poolName);
+        if (swapResult) {
+            params.amountA = swapResult.amountOut;
+            params.txb = swapResult.tx;
+            if (swapResult.coinOut)
+                params.coinA = swapResult.coinOut;
+        }
+        if (swapResult && swapResult.remainingLSTCoin) {
+            params.coinB = swapResult.remainingLSTCoin;
         }
         else {
-            const swapOptionsI2A = {
-                pair: {
-                    coinA: inputObject,
-                    coinB: swapObjectA,
-                },
-                senderAddress: address,
-                inAmount: new BN(inputCoinAmount),
-                slippage: slippage,
-            };
-            const result = await zapSwap(swapOptionsI2A, txb, poolName);
-            if (result) {
-                amountA = result.amountOut;
-                txb = result.tx;
-                if (result.coinOut) {
-                    coin1 = result.coinOut;
-                }
-            }
+            params.amountB = inputAmountToType2.toString();
+            const res = await splitFromExisting(coinDetails.swapObjectB.name, params.amountB, params.txb, suiClient, coinDetails.address);
+            params.txb = res.tx;
+            params.coinB = res.coinOut;
         }
     }
     else {
-        const amount1 = Number(amounts[0]);
-        const amount2 = Number(amounts[1]);
-        const swapOptions = {
-            pair: {
-                coinA: swapObjectA,
-                coinB: swapObjectB,
-            },
-            senderAddress: address,
-            inAmount: new BN(amount1),
-            slippage: slippage,
-        };
-        const ratioQuote = await zapGetQuote(swapGateway, swapOptions, poolName);
-        if (ratioQuote === undefined) {
-            console.error("Error fetching ratioQuote for zap");
-            return undefined;
-        }
-        const amount1InCoinType2 = Number(ratioQuote);
-        const totalAmount = amount2 + amount1InCoinType2;
-        const inputAmountToType1 = Math.floor((inputCoinAmount * amount1InCoinType2) / totalAmount);
-        const inputAmountToType2 = Math.floor((inputCoinAmount * amount2) / totalAmount);
-        const swapOptionsI2A = {
-            pair: {
-                coinA: inputObject,
-                coinB: swapObjectA,
-            },
-            senderAddress: address,
-            inAmount: new BN(inputAmountToType1),
-            slippage: slippage,
-        };
-        const swapOptionsI2B = {
-            pair: {
-                coinA: inputObject,
-                coinB: swapObjectB,
-            },
-            senderAddress: address,
-            inAmount: new BN(inputAmountToType2),
-            slippage: slippage,
-        };
-        if (inputCoinName === coinTypeA) {
-            const result = await zapSwap(swapOptionsI2B, txb, poolName);
-            if (result) {
-                amountB = result.amountOut;
-                txb = result.tx;
-                if (result.coinOut) {
-                    coin2 = result.coinOut;
-                }
-            }
-            amountA = inputAmountToType1.toString();
-            if (result && result.remainingLSTCoin) {
-                coin1 = result.remainingLSTCoin;
-            }
-            else {
-                const res = await splitFromExisting(coinTypeA, amountA, txb, suiClient, address);
-                txb = res.tx;
-                coin1 = res.coinOut;
-            }
+        swapResult = await zapSwap(swapOptionsI2A, params.txb, coinDetails.poolName);
+        if (swapResult) {
+            params.amountA = swapResult.amountOut;
+            params.txb = swapResult.tx;
+            if (swapResult.coinOut)
+                params.coinA = swapResult.coinOut;
         }
-        else if (inputCoinName === coinTypeB) {
-            const result = await zapSwap(swapOptionsI2A, txb, poolName);
-            if (result) {
-                amountA = result.amountOut;
-                txb = result.tx;
-                if (result.coinOut) {
-                    coin1 = result.coinOut;
-                }
-            }
-            if (result && result.remainingLSTCoin) {
-                coin2 = result.remainingLSTCoin;
-            }
-            else {
-                amountB = inputAmountToType2.toString();
-                const res = await splitFromExisting(coinTypeB, amountB, txb, suiClient, address);
-                txb = res.tx;
-                coin2 = res.coinOut;
-            }
-        }
-        else {
-            let result = await zapSwap(swapOptionsI2A, txb, poolName);
-            if (result) {
-                amountA = result.amountOut;
-                txb = result.tx;
-                if (result.coinOut) {
-                    coin1 = result.coinOut;
-                }
-            }
-            result = await zapSwap(swapOptionsI2B, txb, poolName);
-            if (result) {
-                amountB = result.amountOut;
-                txb = result.tx;
-                if (result.coinOut) {
-                    coin2 = result.coinOut;
-                }
-            }
+        swapResult = await zapSwap(swapOptionsI2B, params.txb, coinDetails.poolName);
+        if (swapResult) {
+            params.amountB = swapResult.amountOut;
+            params.txb = swapResult.tx;
+            if (swapResult.coinOut)
+                params.coinB = swapResult.coinOut;
         }
     }
-    if (amountA && amountB && coin1 && coin2) {
+    return params;
+}
+export async function zapDepositTxb(inputCoinName, inputCoinAmount, poolName, slippage, // 0.01 --> 1%, 0.001 --> 0.1%
+address) {
+    const suiClient = getSuiClient();
+    let params = {
+        txb: new Transaction(),
+        coinA: undefined,
+        amountA: undefined,
+        coinB: undefined,
+        amountB: undefined,
+    };
+    const coinDetails = {
+        swapGateway: new SevenKGateway(),
+        inputObject: coinsList[inputCoinName],
+        inputCoinAmount: inputCoinAmount,
+        swapObjectA: coinsList[doubleAssetPoolCoinMap[poolName].coin1],
+        swapObjectB: coinsList[doubleAssetPoolCoinMap[poolName].coin2],
+        address: address,
+        slippage: slippage,
+        poolName: poolName,
+    };
+    const amounts = await getAmounts(poolName, true, "100000001", true);
+    if (Number(amounts[0]) === 0) {
+        params = await handleFirstAmountZero(params, coinDetails, suiClient);
+    }
+    else if (Number(amounts[1]) === 0) {
+        params = await handleSecondAmountZero(params, coinDetails, suiClient);
+    }
+    else {
+        const result = await handleNonZeroAmounts(params, coinDetails, amounts, suiClient);
+        if (!result)
+            return undefined;
+        params = result;
+    }
+    if (params.amountA && params.amountB && params.coinA && params.coinB) {
         // fee charge
-        const fee_address = getConf().FEE_ADDRESS;
         const feePercentage = 0.05;
-        const amountAFee = ((Number(amountA) * feePercentage) / 100).toFixed(0);
-        const amountBFee = ((Number(amountB) * feePercentage) / 100).toFixed(0);
-        const [feeCoinA] = txb.splitCoins(coin1, [amountAFee]);
-        const [feeCoinB] = txb.splitCoins(coin2, [amountBFee]);
-        txb.transferObjects([feeCoinA, feeCoinB], fee_address);
+        const amountAFee = ((Number(params.amountA) * feePercentage) / 100).toFixed(0);
+        const amountBFee = ((Number(params.amountB) * feePercentage) / 100).toFixed(0);
+        const [feeCoinA] = params.txb.splitCoins(params.coinA, [amountAFee]);
+        const [feeCoinB] = params.txb.splitCoins(params.coinB, [amountBFee]);
+        params.txb.transferObjects([feeCoinA, feeCoinB], getConf().FEE_ADDRESS);
+        // Removing fee amounts from amounts and some slippage
         const pool1 = doubleAssetPoolCoinMap[poolName].coin1;
         const pool2 = doubleAssetPoolCoinMap[poolName].coin2;
-        amountA = (Number(amountA) * 0.995).toString();
-        amountB = (Number(amountB) * 0.995).toString();
+        params.amountA = (Number(params.amountA) * 0.995).toString();
+        params.amountB = (Number(params.amountB) * 0.995).toString();
+        // Conditional deposit calls based on pool and protocol
+        const receipt = await getReceipts(poolName, address, true);
+        let amounts = await getAmounts(poolName, true, params.amountA, false);
+        if (amounts[0] > params.amountA || amounts[1] > params.amountB) {
+            amounts = await getAmounts(poolName, false, params.amountB, false);
+        }
+        const [depositCoinA] = params.txb.splitCoins(params.coinA, [amounts[0]]);
+        const [depositCoinB] = params.txb.splitCoins(params.coinB, [amounts[1]]);
+        let someReceipt;
+        if (receipt.length == 0) {
+            [someReceipt] = params.txb.moveCall({
+                target: `0x1::option::none`,
+                typeArguments: [poolInfo[poolName].receiptType],
+                arguments: [],
+            });
+        }
+        else {
+            [someReceipt] = params.txb.moveCall({
+                target: `0x1::option::some`,
+                typeArguments: [receipt[0].content.type],
+                arguments: [params.txb.object(receipt[0].objectId)],
+            });
+        }
         if (poolInfo[poolName].parentProtocolName === "CETUS") {
             if (pool1 === "CETUS" && pool2 === "SUI") {
-                txb = await depositCetusSuiTxb(amountA, amountB, poolName, { address }, txb, coin1, coin2);
+                params.txb = await depositCetusSuiTxb(params.txb, someReceipt, coinDetails.poolName, depositCoinA, depositCoinB);
             }
             else if (pool2 === "SUI") {
-                txb = await depositCetusAlphaSuiTxb(amountA, amountB, poolName, { address }, txb, coin1, coin2);
+                params.txb = await depositCetusAlphaSuiTxb(params.txb, someReceipt, coinDetails.poolName, depositCoinA, depositCoinB);
             }
             else {
-                txb = await depositCetus(amountA, amountB, poolName, { address }, txb, coin1, coin2);
+                params.txb = await depositCetusTxb(params.txb, someReceipt, coinDetails.poolName, depositCoinA, depositCoinB);
             }
         }
         else if (poolInfo[poolName].parentProtocolName === "BLUEFIN") {
             if (poolName === "BLUEFIN-NAVX-VSUI" ||
                 poolName === "BLUEFIN-ALPHA-USDC" ||
                 poolName === "BLUEFIN-BLUE-USDC") {
-                txb = await depositBluefinType2Txb(amountA, amountB, poolName, { address }, txb, coin1, coin2);
+                params.txb = await depositBluefinType2Txb(params.txb, someReceipt, coinDetails.poolName, depositCoinA, depositCoinB);
             }
             else if (pool1 === "SUI") {
-                txb = await depositBluefinSuiFirstTxb(amountA, amountB, poolName, { address }, txb, coin1, coin2);
+                params.txb = await depositBluefinSuiFirstTxb(params.txb, someReceipt, coinDetails.poolName, depositCoinA, depositCoinB);
             }
             else if (pool2 === "SUI") {
-                txb = await depositBluefinSuiSecondTxb(amountA, amountB, poolName, { address }, txb, coin1, coin2);
+                params.txb = await depositBluefinSuiSecondTxb(params.txb, someReceipt, coinDetails.poolName, depositCoinA, depositCoinB);
             }
             else if (pool1 === "STSUI" || pool2 === "STSUI") {
-                txb = await depositBluefinStsuiTxb(amountA, amountB, poolName, { address }, txb, coin1, coin2);
+                params.txb = await depositBluefinStsuiTxb(params.txb, someReceipt, poolName, depositCoinA, depositCoinB);
             }
             else {
-                txb = await depositBluefinType1Txb(amountA, amountB, poolName, { address }, txb, coin1, coin2);
+                params.txb = await depositBluefinType1Txb(params.txb, someReceipt, coinDetails.poolName, depositCoinA, depositCoinB);
             }
         }
+        params.txb.transferObjects([params.coinA, params.coinB], address);
     }
-    txb.setGasBudget(100000000);
-    return txb;
+    params.txb.setGasBudget(100000000);
+    return params.txb;
 }
 async function zapGetQuote(swapGateway, swapOptions, poolName) {
     if (swapOptions.pair.coinA.name === "SUI" &&
         swapOptions.pair.coinB.name === "STSUI") {
-        const exchangeRate = new Decimal(await stSuiExchangeRate());
+        const exchangeRate = new Decimal(await stSuiExchangeRate(getStSuiConf().LST_INFO, true));
         const amount = new Decimal(swapOptions.inAmount ? swapOptions.inAmount.toString() : "0");
         return amount.div(exchangeRate).toString();
     }
     else if (swapOptions.pair.coinA.name === "STSUI" &&
         swapOptions.pair.coinB.name === "SUI") {
-        const exchangeRate = new Decimal(await stSuiExchangeRate());
+        const exchangeRate = new Decimal(await stSuiExchangeRate(getStSuiConf().LST_INFO, true));
         const amount = new Decimal(swapOptions.inAmount ? swapOptions.inAmount.toString() : "0");
         return amount.mul(exchangeRate).toString();
     }
@@ -324,132 +349,16 @@ async function splitFromExisting(coinType, amount, txb, suiClient, address) {
         coinOut: coin,
     };
 }
-const depositCetus = async (amountA, amountB, poolName, options, transaction = undefined, coin1Arg, coin2Arg) => {
-    const address = options.address;
-    let txb;
-    if (transaction)
-        txb = transaction;
-    else
-        txb = new Transaction();
-    poolName = poolName.toUpperCase();
+const depositCetusTxb = async (txb, someReceipt, poolName, depositCoinA, depositCoinB) => {
     const poolinfo = poolInfo[poolName];
     const pool1 = doubleAssetPoolCoinMap[poolName].coin1;
     const pool2 = doubleAssetPoolCoinMap[poolName].coin2;
-    const receipt = await getReceipts(poolName, address, true);
-    amountA = (Number(amountA) * 0.999).toString();
-    amountB = (Number(amountB) * 0.999).toString();
-    let amounts = await getAmounts(poolName, true, amountA);
-    if (amounts === undefined || amounts[0] > amountA || amounts[1] > amountB) {
-        amounts = await getAmounts(poolName, false, amountB);
-    }
-    if (amounts && coin1Arg !== undefined && coin2Arg !== undefined) {
-        const [depositCoinA] = txb.splitCoins(coin1Arg, [amounts[0]]);
-        const [depositCoinB] = txb.splitCoins(coin2Arg, [amounts[1]]);
-        let someReceipt;
-        if (receipt.length == 0) {
-            [someReceipt] = txb.moveCall({
-                target: `0x1::option::none`,
-                typeArguments: [poolInfo[poolName].receiptType],
-                arguments: [],
-            });
-        }
-        else {
-            [someReceipt] = txb.moveCall({
-                target: `0x1::option::some`,
-                typeArguments: [receipt[0].content.type],
-                arguments: [txb.object(receipt[0].objectId)],
-            });
-        }
-        if (poolName == "WUSDC-WBTC" ||
-            poolName == "USDC-USDT" ||
-            poolName == "USDC-WUSDC" ||
-            poolName == "USDC-ETH") {
-            txb.moveCall({
-                target: `${getConf().ALPHA_LATEST_PACKAGE_ID}::alphafi_cetus_pool_base_a::user_deposit`,
-                typeArguments: [coinsList[pool1].type, coinsList[pool2].type],
-                arguments: [
-                    txb.object(getConf().VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().CETUS_REWARDER_GLOBAL_VAULT_ID),
-                    txb.object(cetusPoolMap[`${pool1}-SUI`]),
-                    txb.object(cetusPoolMap["CETUS-SUI"]),
-                    txb.object(cetusPoolMap[poolName]),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        else {
-            txb.moveCall({
-                target: `${getConf().ALPHA_LATEST_PACKAGE_ID}::alphafi_cetus_pool::user_deposit`,
-                typeArguments: [coinsList[pool1].type, coinsList[pool2].type],
-                arguments: [
-                    txb.object(getConf().VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().CETUS_REWARDER_GLOBAL_VAULT_ID),
-                    txb.object(cetusPoolMap[`${pool2}-SUI`]),
-                    txb.object(cetusPoolMap["CETUS-SUI"]),
-                    txb.object(cetusPoolMap[poolName]),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        txb.transferObjects([coin1Arg, coin2Arg], address);
-    }
-    else {
-        throw new Error(`No ${pool1} or ${pool2} Coins`);
-    }
-    return txb;
-};
-const depositCetusAlphaSuiTxb = async (amountA, amountB, poolName, options, transaction = undefined, coin1Arg, coin2Arg) => {
-    const address = options.address;
-    let txb;
-    if (transaction)
-        txb = transaction;
-    else
-        txb = new Transaction();
-    poolName = poolName.toUpperCase();
-    const pool1 = doubleAssetPoolCoinMap[poolName].coin1;
-    const pool2 = doubleAssetPoolCoinMap[poolName].coin2;
-    const receipt = await getReceipts(poolName, address, true);
-    amountA = (Number(amountA) * 0.999).toString();
-    amountB = (Number(amountB) * 0.999).toString();
-    let amounts = await getAmounts(poolName, true, amountA);
-    if (amounts === undefined || amounts[0] > amountA || amounts[1] > amountB) {
-        amounts = await getAmounts(poolName, false, amountB);
-    }
-    if (amounts && coin1Arg != undefined && coin2Arg !== undefined) {
-        const [depositCoinA] = txb.splitCoins(coin1Arg, [amounts[0]]);
-        const [depositCoinB] = txb.splitCoins(coin2Arg, [amounts[1]]);
-        const poolinfo = poolInfo[poolName];
-        let someReceipt;
-        if (receipt.length == 0) {
-            [someReceipt] = txb.moveCall({
-                target: `0x1::option::none`,
-                typeArguments: [poolinfo.receiptType],
-                arguments: [],
-            });
-        }
-        else {
-            [someReceipt] = txb.moveCall({
-                target: `0x1::option::some`,
-                typeArguments: [receipt[0].content.type],
-                arguments: [txb.object(receipt[0].objectId)],
-            });
-        }
+    if (poolName == "WUSDC-WBTC" ||
+        poolName == "USDC-USDT" ||
+        poolName == "USDC-WUSDC" ||
+        poolName == "USDC-ETH") {
         txb.moveCall({
-            target: `${poolinfo.packageId}::alphafi_cetus_sui_pool::user_deposit`,
+            target: `${getConf().ALPHA_LATEST_PACKAGE_ID}::alphafi_cetus_pool_base_a::user_deposit`,
             typeArguments: [coinsList[pool1].type, coinsList[pool2].type],
             arguments: [
                 txb.object(getConf().VERSION),
@@ -461,59 +370,18 @@ const depositCetusAlphaSuiTxb = async (amountA, amountB, poolName, options, tran
                 txb.object(poolinfo.investorId),
                 txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
                 txb.object(getConf().CETUS_REWARDER_GLOBAL_VAULT_ID),
+                txb.object(cetusPoolMap[`${pool1}-SUI`]),
                 txb.object(cetusPoolMap["CETUS-SUI"]),
                 txb.object(cetusPoolMap[poolName]),
                 txb.object(getConf().CLOCK_PACKAGE_ID),
             ],
         });
-        txb.transferObjects([coin1Arg, coin2Arg], address);
     }
     else {
-        throw new Error(`No ${pool1} or ${pool2} Coins`);
-    }
-    return txb;
-};
-const depositCetusSuiTxb = async (amountA, amountB, poolName, options, transaction = undefined, coin1Arg, coin2Arg) => {
-    const address = options.address;
-    let txb;
-    if (transaction)
-        txb = transaction;
-    else
-        txb = new Transaction();
-    poolName = poolName.toUpperCase();
-    const pool1 = doubleAssetPoolCoinMap[poolName].coin1;
-    const pool2 = doubleAssetPoolCoinMap[poolName].coin2;
-    const receipt = await getReceipts(poolName, address, true);
-    amountA = (Number(amountA) * 0.999).toString();
-    amountB = (Number(amountB) * 0.999).toString();
-    let amounts = await getAmounts(poolName, true, amountA);
-    if (amounts === undefined || amounts[0] > amountA || amounts[1] > amountB) {
-        amounts = await getAmounts(poolName, false, amountB);
-    }
-    if (amounts && coin1Arg && coin2Arg) {
-        const [depositCoinA] = txb.splitCoins(coin1Arg, [amounts[0]]);
-        const [depositCoinB] = txb.splitCoins(coin2Arg, [amounts[1]]);
-        const poolinfo = poolInfo[poolName];
-        let someReceipt;
-        if (receipt.length == 0) {
-            [someReceipt] = txb.moveCall({
-                target: `0x1::option::none`,
-                typeArguments: [poolinfo.receiptType],
-                arguments: [],
-            });
-        }
-        else {
-            [someReceipt] = txb.moveCall({
-                target: `0x1::option::some`,
-                typeArguments: [receipt[0].content.type],
-                arguments: [txb.object(receipt[0].objectId)],
-            });
-        }
         txb.moveCall({
-            target: `${poolinfo.packageId}::alphafi_cetus_sui_pool::user_deposit`,
+            target: `${getConf().ALPHA_LATEST_PACKAGE_ID}::alphafi_cetus_pool::user_deposit`,
             typeArguments: [coinsList[pool1].type, coinsList[pool2].type],
             arguments: [
-                txb.object(getConf().ALPHA_2_VERSION),
                 txb.object(getConf().VERSION),
                 someReceipt,
                 txb.object(poolinfo.poolId),
@@ -523,1196 +391,1038 @@ const depositCetusSuiTxb = async (amountA, amountB, poolName, options, transacti
                 txb.object(poolinfo.investorId),
                 txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
                 txb.object(getConf().CETUS_REWARDER_GLOBAL_VAULT_ID),
+                txb.object(cetusPoolMap[`${pool2}-SUI`]),
+                txb.object(cetusPoolMap["CETUS-SUI"]),
                 txb.object(cetusPoolMap[poolName]),
                 txb.object(getConf().CLOCK_PACKAGE_ID),
             ],
         });
-        txb.transferObjects([coin1Arg, coin2Arg], address);
-    }
-    else {
-        throw new Error(`No ${pool1} or ${pool2} Coins`);
     }
     return txb;
 };
-const depositBluefinSuiFirstTxb = async (amountA, amountB, poolName, options, transaction = undefined, coin1Arg, coin2Arg) => {
-    const address = options.address;
-    let txb;
-    if (transaction)
-        txb = transaction;
-    else
-        txb = new Transaction();
-    poolName = poolName.toUpperCase();
+const depositCetusAlphaSuiTxb = async (txb, someReceipt, poolName, depositCoinA, depositCoinB) => {
+    const poolinfo = poolInfo[poolName];
     const pool1 = doubleAssetPoolCoinMap[poolName].coin1;
     const pool2 = doubleAssetPoolCoinMap[poolName].coin2;
-    const receipt = await getReceipts(poolName, address, true);
-    amountA = (Number(amountA) * 0.999).toString();
-    amountB = (Number(amountB) * 0.999).toString();
-    let amounts = await getAmounts(poolName, true, amountA);
-    if (amounts === undefined || amounts[0] > amountA || amounts[1] > amountB) {
-        amounts = await getAmounts(poolName, false, amountB);
-    }
-    if (amounts && coin1Arg && coin2Arg) {
-        const [depositCoinA] = txb.splitCoins(txb.gas, [amounts[0]]);
-        const [depositCoinB] = txb.splitCoins(coin2Arg, [amounts[1]]);
-        const poolinfo = poolInfo[poolName];
-        let someReceipt;
-        if (receipt.length == 0) {
-            [someReceipt] = txb.moveCall({
-                target: `0x1::option::none`,
-                typeArguments: [poolinfo.receiptType],
-                arguments: [],
-            });
-        }
-        else {
-            [someReceipt] = txb.moveCall({
-                target: `0x1::option::some`,
-                typeArguments: [receipt[0].content.type],
-                arguments: [txb.object(receipt[0].objectId)],
-            });
-        }
-        if (poolName === "BLUEFIN-SUI-USDC") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_sui_first_pool::user_deposit_v2`,
-                typeArguments: [
-                    coinsList[pool1].type,
-                    coinsList[pool2].type,
-                    coinsList["BLUE"].type,
-                    coinsList["SUI"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_4_VERSION),
-                    txb.object(getConf().VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_SUI_USDC_POOL),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(cetusPoolMap["USDC-SUI"]),
-                    txb.object(getConf().LST_INFO),
-                    txb.object(getConf().SUI_SYSTEM_STATE),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        else if (poolName === "BLUEFIN-SUI-BUCK") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_sui_first_pool::user_deposit_v2`,
-                typeArguments: [
-                    coinsList[pool1].type,
-                    coinsList[pool2].type,
-                    coinsList["BLUE"].type,
-                    coinsList["SUI"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_4_VERSION),
-                    txb.object(getConf().VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_SUI_BUCK_POOL),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(cetusPoolMap["BUCK-SUI"]),
-                    txb.object(getConf().LST_INFO),
-                    txb.object(getConf().SUI_SYSTEM_STATE),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        else if (poolName === "BLUEFIN-SUI-AUSD") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_sui_first_pool::user_deposit_v2`,
-                typeArguments: [
-                    coinsList[pool1].type,
-                    coinsList[pool2].type,
-                    coinsList["BLUE"].type,
-                    coinsList["SUI"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_4_VERSION),
-                    txb.object(getConf().VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_SUI_AUSD_POOL),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(cetusPoolMap["AUSD-SUI"]),
-                    txb.object(getConf().LST_INFO),
-                    txb.object(getConf().SUI_SYSTEM_STATE),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        else if (poolName === "BLUEFIN-AUTOBALANCE-SUI-USDC") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_sui_first_pool::user_deposit_v2`,
-                typeArguments: [
-                    coinsList[pool1].type,
-                    coinsList[pool2].type,
-                    coinsList["BLUE"].type,
-                    coinsList["SUI"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_BLUEFIN_AUTOBALANCE_VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_SUI_USDC_POOL),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(cetusPoolMap["USDC-SUI"]),
-                    txb.object(getConf().LST_INFO),
-                    txb.object(getConf().SUI_SYSTEM_STATE),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        txb.transferObjects([coin1Arg, coin2Arg], address);
-    }
-    else {
-        throw new Error(`No ${pool1} or ${pool2} Coins`);
-    }
+    txb.moveCall({
+        target: `${poolinfo.packageId}::alphafi_cetus_sui_pool::user_deposit`,
+        typeArguments: [coinsList[pool1].type, coinsList[pool2].type],
+        arguments: [
+            txb.object(getConf().VERSION),
+            someReceipt,
+            txb.object(poolinfo.poolId),
+            depositCoinA,
+            depositCoinB,
+            txb.object(getConf().ALPHA_DISTRIBUTOR),
+            txb.object(poolinfo.investorId),
+            txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+            txb.object(getConf().CETUS_REWARDER_GLOBAL_VAULT_ID),
+            txb.object(cetusPoolMap["CETUS-SUI"]),
+            txb.object(cetusPoolMap[poolName]),
+            txb.object(getConf().CLOCK_PACKAGE_ID),
+        ],
+    });
+    return txb;
+};
+const depositCetusSuiTxb = async (txb, someReceipt, poolName, depositCoinA, depositCoinB) => {
+    const poolinfo = poolInfo[poolName];
+    const pool1 = doubleAssetPoolCoinMap[poolName].coin1;
+    const pool2 = doubleAssetPoolCoinMap[poolName].coin2;
+    txb.moveCall({
+        target: `${poolinfo.packageId}::alphafi_cetus_sui_pool::user_deposit`,
+        typeArguments: [coinsList[pool1].type, coinsList[pool2].type],
+        arguments: [
+            txb.object(getConf().ALPHA_2_VERSION),
+            txb.object(getConf().VERSION),
+            someReceipt,
+            txb.object(poolinfo.poolId),
+            depositCoinA,
+            depositCoinB,
+            txb.object(getConf().ALPHA_DISTRIBUTOR),
+            txb.object(poolinfo.investorId),
+            txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+            txb.object(getConf().CETUS_REWARDER_GLOBAL_VAULT_ID),
+            txb.object(cetusPoolMap[poolName]),
+            txb.object(getConf().CLOCK_PACKAGE_ID),
+        ],
+    });
     return txb;
 };
-const depositBluefinType1Txb = async (amountA, amountB, poolName, options, transaction = undefined, coin1Arg, coin2Arg) => {
-    const address = options.address;
-    let txb;
-    if (transaction)
-        txb = transaction;
-    else
-        txb = new Transaction();
-    poolName = poolName.toUpperCase();
+const depositBluefinSuiFirstTxb = async (txb, someReceipt, poolName, depositCoinA, depositCoinB) => {
+    const poolinfo = poolInfo[poolName];
     const pool1 = doubleAssetPoolCoinMap[poolName].coin1;
     const pool2 = doubleAssetPoolCoinMap[poolName].coin2;
-    const receipt = await getReceipts(poolName, address, true);
-    amountA = (Number(amountA) * 0.999).toString();
-    amountB = (Number(amountB) * 0.999).toString();
-    let amounts = await getAmounts(poolName, true, amountA);
-    if (amounts === undefined || amounts[0] > amountA || amounts[1] > amountB) {
-        amounts = await getAmounts(poolName, false, amountB);
+    if (poolName === "BLUEFIN-SUI-USDC") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_sui_first_pool::user_deposit_v2`,
+            typeArguments: [
+                coinsList[pool1].type,
+                coinsList[pool2].type,
+                coinsList["BLUE"].type,
+                coinsList["SUI"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_4_VERSION),
+                txb.object(getConf().VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_SUI_USDC_POOL),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(cetusPoolMap["USDC-SUI"]),
+                txb.object(getConf().LST_INFO),
+                txb.object(getConf().SUI_SYSTEM_STATE),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
     }
-    if (amounts && coin1Arg && coin2Arg) {
-        const [depositCoinA] = txb.splitCoins(coin1Arg, [amounts[0]]);
-        const [depositCoinB] = txb.splitCoins(coin2Arg, [amounts[1]]);
-        const poolinfo = poolInfo[poolName];
-        let someReceipt;
-        if (receipt.length == 0) {
-            [someReceipt] = txb.moveCall({
-                target: `0x1::option::none`,
-                typeArguments: [poolinfo.receiptType],
-                arguments: [],
-            });
-        }
-        else {
-            [someReceipt] = txb.moveCall({
-                target: `0x1::option::some`,
-                typeArguments: [receipt[0].content.type],
-                arguments: [txb.object(receipt[0].objectId)],
-            });
-        }
-        if (poolName === "BLUEFIN-USDT-USDC") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_type_1_pool::user_deposit_v2`,
-                typeArguments: [
-                    coinsList[pool1].type,
-                    coinsList[pool2].type,
-                    coinsList["BLUE"].type,
-                    coinsList["SUI"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_4_VERSION),
-                    txb.object(getConf().VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_USDT_USDC_POOL),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(cetusPoolMap["USDC-USDT"]),
-                    txb.object(cetusPoolMap["USDC-SUI"]),
-                    txb.object(getConf().LST_INFO),
-                    txb.object(getConf().SUI_SYSTEM_STATE),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        else if (poolName === "BLUEFIN-AUSD-USDC") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_type_1_pool::user_deposit_v2`,
-                typeArguments: [
-                    coinsList[pool1].type,
-                    coinsList[pool2].type,
-                    coinsList["BLUE"].type,
-                    coinsList["SUI"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_4_VERSION),
-                    txb.object(getConf().VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_AUSD_USDC_POOL),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(cetusPoolMap["USDC-AUSD"]),
-                    txb.object(cetusPoolMap["USDC-SUI"]),
-                    txb.object(getConf().LST_INFO),
-                    txb.object(getConf().SUI_SYSTEM_STATE),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        else if (poolName === "BLUEFIN-WBTC-USDC") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_type_1_pool::user_deposit_v2`,
-                typeArguments: [
-                    coinsList[pool1].type,
-                    coinsList[pool2].type,
-                    coinsList["BLUE"].type,
-                    coinsList["SUI"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_4_VERSION),
-                    txb.object(getConf().VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_WBTC_USDC_POOL),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(cetusPoolMap["USDC-WBTC"]),
-                    txb.object(cetusPoolMap["USDC-SUI"]),
-                    txb.object(getConf().LST_INFO),
-                    txb.object(getConf().SUI_SYSTEM_STATE),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        else if (poolName === "BLUEFIN-SEND-USDC") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_type_1_pool::user_deposit_v2`,
-                typeArguments: [
-                    coinsList[pool1].type,
-                    coinsList[pool2].type,
-                    coinsList["BLUE"].type,
-                    coinsList["SUI"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_4_VERSION),
-                    txb.object(getConf().VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_SEND_USDC_POOL),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(cetusPoolMap["USDC-SEND"]),
-                    txb.object(cetusPoolMap["USDC-SUI"]),
-                    txb.object(getConf().LST_INFO),
-                    txb.object(getConf().SUI_SYSTEM_STATE),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        else if (poolName === "BLUEFIN-STSUI-USDC") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_type_1_pool::user_deposit`,
-                typeArguments: [
-                    coinsList[pool1].type,
-                    coinsList[pool2].type,
-                    coinsList["BLUE"].type,
-                    coinsList["SUI"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_4_VERSION),
-                    txb.object(getConf().VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_STSUI_USDC_POOL),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(cetusPoolMap["USDC-STSUI"]),
-                    txb.object(cetusPoolMap["USDC-SUI"]),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        else if (poolName === "BLUEFIN-AUTOBALANCE-USDT-USDC") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_type_1_pool::user_deposit_v2`,
-                typeArguments: [
-                    coinsList["USDT"].type,
-                    coinsList["USDC"].type,
-                    coinsList["BLUE"].type,
-                    coinsList["SUI"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_BLUEFIN_AUTOBALANCE_VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_USDT_USDC_POOL),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(cetusPoolMap["USDC-USDT"]),
-                    txb.object(cetusPoolMap["USDC-SUI"]),
-                    txb.object(getConf().LST_INFO),
-                    txb.object(getConf().SUI_SYSTEM_STATE),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        else if (poolName === "BLUEFIN-SUIUSDT-USDC") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_type_1_pool::user_deposit_v2`,
-                typeArguments: [
-                    coinsList[pool1].type,
-                    coinsList[pool2].type,
-                    coinsList["BLUE"].type,
-                    coinsList["SUI"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_4_VERSION),
-                    txb.object(getConf().VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_SUIUSDT_USDC_POOL),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(cetusPoolMap["USDC-SUIUSDT"]),
-                    txb.object(cetusPoolMap["USDC-SUI"]),
-                    txb.object(getConf().LST_INFO),
-                    txb.object(getConf().SUI_SYSTEM_STATE),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        else if (poolName === "BLUEFIN-AUTOBALANCE-SUIUSDT-USDC") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_type_1_pool::user_deposit_v2`,
-                typeArguments: [
-                    coinsList["SUIUSDT"].type,
-                    coinsList["USDC"].type,
-                    coinsList["BLUE"].type,
-                    coinsList["SUI"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_BLUEFIN_AUTOBALANCE_VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_SUIUSDT_USDC_POOL),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(cetusPoolMap["USDC-SUIUSDT"]),
-                    txb.object(cetusPoolMap["USDC-SUI"]),
-                    txb.object(getConf().LST_INFO),
-                    txb.object(getConf().SUI_SYSTEM_STATE),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        else if (poolName === "BLUEFIN-AUTOBALANCE-DEEP-BLUE") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_type_1_pool::user_deposit_v2`,
-                typeArguments: [
-                    coinsList["DEEP"].type,
-                    coinsList["BLUE"].type,
-                    coinsList["BLUE"].type,
-                    coinsList["SUI"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_BLUEFIN_AUTOBALANCE_VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_DEEP_BLUE_POOL),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(cetusPoolMap["BLUE-DEEP"]),
-                    txb.object(cetusPoolMap["BLUE-SUI"]),
-                    txb.object(getConf().LST_INFO),
-                    txb.object(getConf().SUI_SYSTEM_STATE),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        txb.transferObjects([coin1Arg, coin2Arg], address);
+    else if (poolName === "BLUEFIN-SUI-BUCK") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_sui_first_pool::user_deposit_v2`,
+            typeArguments: [
+                coinsList[pool1].type,
+                coinsList[pool2].type,
+                coinsList["BLUE"].type,
+                coinsList["SUI"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_4_VERSION),
+                txb.object(getConf().VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_SUI_BUCK_POOL),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(cetusPoolMap["BUCK-SUI"]),
+                txb.object(getConf().LST_INFO),
+                txb.object(getConf().SUI_SYSTEM_STATE),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
     }
-    else {
-        throw new Error(`No ${pool1} or ${pool2} Coins`);
+    else if (poolName === "BLUEFIN-SUI-AUSD") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_sui_first_pool::user_deposit_v2`,
+            typeArguments: [
+                coinsList[pool1].type,
+                coinsList[pool2].type,
+                coinsList["BLUE"].type,
+                coinsList["SUI"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_4_VERSION),
+                txb.object(getConf().VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_SUI_AUSD_POOL),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(cetusPoolMap["AUSD-SUI"]),
+                txb.object(getConf().LST_INFO),
+                txb.object(getConf().SUI_SYSTEM_STATE),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
+    }
+    else if (poolName === "BLUEFIN-AUTOBALANCE-SUI-USDC") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_sui_first_pool::user_deposit_v2`,
+            typeArguments: [
+                coinsList[pool1].type,
+                coinsList[pool2].type,
+                coinsList["BLUE"].type,
+                coinsList["SUI"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_BLUEFIN_AUTOBALANCE_VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_SUI_USDC_POOL),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(cetusPoolMap["USDC-SUI"]),
+                txb.object(getConf().LST_INFO),
+                txb.object(getConf().SUI_SYSTEM_STATE),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
     }
     return txb;
 };
-const depositBluefinType2Txb = async (amountA, amountB, poolName, options, transaction = undefined, coin1Arg, coin2Arg) => {
-    const address = options.address;
-    let txb;
-    if (transaction)
-        txb = transaction;
-    else
-        txb = new Transaction();
-    poolName = poolName.toUpperCase();
+const depositBluefinType1Txb = async (txb, someReceipt, poolName, depositCoinA, depositCoinB) => {
+    const poolinfo = poolInfo[poolName];
     const pool1 = doubleAssetPoolCoinMap[poolName].coin1;
     const pool2 = doubleAssetPoolCoinMap[poolName].coin2;
-    const receipt = await getReceipts(poolName, address, true);
-    amountA = (Number(amountA) * 0.999).toString();
-    amountB = (Number(amountB) * 0.999).toString();
-    let amounts = await getAmounts(poolName, true, amountA);
-    if (amounts === undefined || amounts[0] > amountA || amounts[1] > amountB) {
-        amounts = await getAmounts(poolName, false, amountB);
+    if (poolName === "BLUEFIN-USDT-USDC") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_type_1_pool::user_deposit_v2`,
+            typeArguments: [
+                coinsList[pool1].type,
+                coinsList[pool2].type,
+                coinsList["BLUE"].type,
+                coinsList["SUI"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_4_VERSION),
+                txb.object(getConf().VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_USDT_USDC_POOL),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(cetusPoolMap["USDC-USDT"]),
+                txb.object(cetusPoolMap["USDC-SUI"]),
+                txb.object(getConf().LST_INFO),
+                txb.object(getConf().SUI_SYSTEM_STATE),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
     }
-    if (amounts && coin1Arg && coin2Arg) {
-        const [depositCoinA] = txb.splitCoins(coin1Arg, [amounts[0]]);
-        const [depositCoinB] = txb.splitCoins(coin2Arg, [amounts[1]]);
-        const poolinfo = poolInfo[poolName];
-        let someReceipt;
-        if (receipt.length == 0) {
-            [someReceipt] = txb.moveCall({
-                target: `0x1::option::none`,
-                typeArguments: [poolinfo.receiptType],
-                arguments: [],
-            });
-        }
-        else {
-            [someReceipt] = txb.moveCall({
-                target: `0x1::option::some`,
-                typeArguments: [receipt[0].content.type],
-                arguments: [txb.object(receipt[0].objectId)],
-            });
-        }
-        if (poolName === "BLUEFIN-ALPHA-USDC") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_type_2_pool::user_deposit_v2`,
-                typeArguments: [
-                    coinsList[pool1].type,
-                    coinsList[pool2].type,
-                    coinsList["BLUE"].type,
-                    coinsList["SUI"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_4_VERSION),
-                    txb.object(getConf().VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_ALPHA_USDC_POOL),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(cetusPoolMap["ALPHA-USDC"]),
-                    txb.object(cetusPoolMap["USDC-SUI"]),
-                    txb.object(getConf().LST_INFO),
-                    txb.object(getConf().SUI_SYSTEM_STATE),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        else if (poolName === "BLUEFIN-NAVX-VSUI") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_type_2_pool::user_deposit_v2`,
-                typeArguments: [
-                    coinsList[pool1].type,
-                    coinsList[pool2].type,
-                    coinsList["BLUE"].type,
-                    coinsList["SUI"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_4_VERSION),
-                    txb.object(getConf().VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_NAVX_VSUI_POOL),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(cetusPoolMap["NAVX-VSUI"]),
-                    txb.object(cetusPoolMap["VSUI-SUI"]),
-                    txb.object(getConf().LST_INFO),
-                    txb.object(getConf().SUI_SYSTEM_STATE),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        else if (poolName === "BLUEFIN-BLUE-USDC") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_type_2_pool::user_deposit_v2`,
-                typeArguments: [
-                    coinsList[pool1].type,
-                    coinsList[pool2].type,
-                    coinsList["DEEP"].type,
-                    coinsList["SUI"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_4_VERSION),
-                    txb.object(getConf().VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_BLUE_USDC_POOL),
-                    txb.object(getConf().BLUEFIN_DEEP_SUI_POOL),
-                    txb.object(cetusPoolMap["BLUE-USDC"]),
-                    txb.object(cetusPoolMap["USDC-SUI"]),
-                    txb.object(getConf().LST_INFO),
-                    txb.object(getConf().SUI_SYSTEM_STATE),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        else if (poolName === "BLUEFIN-STSUI-ETH") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_type_2_pool::user_deposit`,
-                typeArguments: [
-                    coinsList[pool1].type,
-                    coinsList[pool2].type,
-                    coinsList["BLUE"].type,
-                    coinsList["SUI"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_4_VERSION),
-                    txb.object(getConf().VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_STSUI_ETH_POOL),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(cetusPoolMap["STSUI-ETH"]),
-                    txb.object(cetusPoolMap["ETH-SUI"]),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        else if (poolName === "BLUEFIN-STSUI-WSOL") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_type_2_pool::user_deposit`,
-                typeArguments: [
-                    coinsList[pool1].type,
-                    coinsList[pool2].type,
-                    coinsList["BLUE"].type,
-                    coinsList["SUI"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_4_VERSION),
-                    txb.object(getConf().VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_STSUI_WSOL_POOL),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(cetusPoolMap["STSUI-WSOL"]),
-                    txb.object(cetusPoolMap["WSOL-SUI"]),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        txb.transferObjects([coin1Arg, coin2Arg], address);
+    else if (poolName === "BLUEFIN-AUSD-USDC") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_type_1_pool::user_deposit_v2`,
+            typeArguments: [
+                coinsList[pool1].type,
+                coinsList[pool2].type,
+                coinsList["BLUE"].type,
+                coinsList["SUI"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_4_VERSION),
+                txb.object(getConf().VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_AUSD_USDC_POOL),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(cetusPoolMap["USDC-AUSD"]),
+                txb.object(cetusPoolMap["USDC-SUI"]),
+                txb.object(getConf().LST_INFO),
+                txb.object(getConf().SUI_SYSTEM_STATE),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
     }
-    else {
-        throw new Error(`No ${pool1} or ${pool2} Coins`);
+    else if (poolName === "BLUEFIN-WBTC-USDC") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_type_1_pool::user_deposit_v2`,
+            typeArguments: [
+                coinsList[pool1].type,
+                coinsList[pool2].type,
+                coinsList["BLUE"].type,
+                coinsList["SUI"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_4_VERSION),
+                txb.object(getConf().VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_WBTC_USDC_POOL),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(cetusPoolMap["USDC-WBTC"]),
+                txb.object(cetusPoolMap["USDC-SUI"]),
+                txb.object(getConf().LST_INFO),
+                txb.object(getConf().SUI_SYSTEM_STATE),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
+    }
+    else if (poolName === "BLUEFIN-SEND-USDC") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_type_1_pool::user_deposit_v2`,
+            typeArguments: [
+                coinsList[pool1].type,
+                coinsList[pool2].type,
+                coinsList["BLUE"].type,
+                coinsList["SUI"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_4_VERSION),
+                txb.object(getConf().VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_SEND_USDC_POOL),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(cetusPoolMap["USDC-SEND"]),
+                txb.object(cetusPoolMap["USDC-SUI"]),
+                txb.object(getConf().LST_INFO),
+                txb.object(getConf().SUI_SYSTEM_STATE),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
+    }
+    else if (poolName === "BLUEFIN-STSUI-USDC") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_type_1_pool::user_deposit`,
+            typeArguments: [
+                coinsList[pool1].type,
+                coinsList[pool2].type,
+                coinsList["BLUE"].type,
+                coinsList["SUI"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_4_VERSION),
+                txb.object(getConf().VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_STSUI_USDC_POOL),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(cetusPoolMap["USDC-STSUI"]),
+                txb.object(cetusPoolMap["USDC-SUI"]),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
+    }
+    else if (poolName === "BLUEFIN-AUTOBALANCE-USDT-USDC") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_type_1_pool::user_deposit_v2`,
+            typeArguments: [
+                coinsList["USDT"].type,
+                coinsList["USDC"].type,
+                coinsList["BLUE"].type,
+                coinsList["SUI"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_BLUEFIN_AUTOBALANCE_VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_USDT_USDC_POOL),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(cetusPoolMap["USDC-USDT"]),
+                txb.object(cetusPoolMap["USDC-SUI"]),
+                txb.object(getConf().LST_INFO),
+                txb.object(getConf().SUI_SYSTEM_STATE),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
+    }
+    else if (poolName === "BLUEFIN-SUIUSDT-USDC") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_type_1_pool::user_deposit_v2`,
+            typeArguments: [
+                coinsList[pool1].type,
+                coinsList[pool2].type,
+                coinsList["BLUE"].type,
+                coinsList["SUI"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_4_VERSION),
+                txb.object(getConf().VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_SUIUSDT_USDC_POOL),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(cetusPoolMap["USDC-SUIUSDT"]),
+                txb.object(cetusPoolMap["USDC-SUI"]),
+                txb.object(getConf().LST_INFO),
+                txb.object(getConf().SUI_SYSTEM_STATE),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
+    }
+    else if (poolName === "BLUEFIN-AUTOBALANCE-SUIUSDT-USDC") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_type_1_pool::user_deposit_v2`,
+            typeArguments: [
+                coinsList["SUIUSDT"].type,
+                coinsList["USDC"].type,
+                coinsList["BLUE"].type,
+                coinsList["SUI"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_BLUEFIN_AUTOBALANCE_VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_SUIUSDT_USDC_POOL),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(cetusPoolMap["USDC-SUIUSDT"]),
+                txb.object(cetusPoolMap["USDC-SUI"]),
+                txb.object(getConf().LST_INFO),
+                txb.object(getConf().SUI_SYSTEM_STATE),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
+    }
+    else if (poolName === "BLUEFIN-AUTOBALANCE-DEEP-BLUE") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_type_1_pool::user_deposit_v2`,
+            typeArguments: [
+                coinsList["DEEP"].type,
+                coinsList["BLUE"].type,
+                coinsList["BLUE"].type,
+                coinsList["SUI"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_BLUEFIN_AUTOBALANCE_VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_DEEP_BLUE_POOL),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(cetusPoolMap["BLUE-DEEP"]),
+                txb.object(cetusPoolMap["BLUE-SUI"]),
+                txb.object(getConf().LST_INFO),
+                txb.object(getConf().SUI_SYSTEM_STATE),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
     }
     return txb;
 };
-const depositBluefinSuiSecondTxb = async (amountA, amountB, poolName, options, transaction = undefined, coin1Arg, coin2Arg) => {
-    const address = options.address;
-    let txb;
-    if (transaction)
-        txb = transaction;
-    else
-        txb = new Transaction();
-    poolName = poolName.toUpperCase();
+const depositBluefinType2Txb = async (txb, someReceipt, poolName, depositCoinA, depositCoinB) => {
+    const poolinfo = poolInfo[poolName];
     const pool1 = doubleAssetPoolCoinMap[poolName].coin1;
     const pool2 = doubleAssetPoolCoinMap[poolName].coin2;
-    const receipt = await getReceipts(poolName, address, true);
-    amountA = (Number(amountA) * 0.999).toString();
-    amountB = (Number(amountB) * 0.999).toString();
-    let amounts = await getAmounts(poolName, true, amountA);
-    if (amounts === undefined || amounts[0] > amountA || amounts[1] > amountB) {
-        amounts = await getAmounts(poolName, false, amountB);
+    if (poolName === "BLUEFIN-ALPHA-USDC") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_type_2_pool::user_deposit_v2`,
+            typeArguments: [
+                coinsList[pool1].type,
+                coinsList[pool2].type,
+                coinsList["BLUE"].type,
+                coinsList["SUI"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_4_VERSION),
+                txb.object(getConf().VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_ALPHA_USDC_POOL),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(cetusPoolMap["ALPHA-USDC"]),
+                txb.object(cetusPoolMap["USDC-SUI"]),
+                txb.object(getConf().LST_INFO),
+                txb.object(getConf().SUI_SYSTEM_STATE),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
     }
-    if (amounts && coin1Arg && coin2Arg) {
-        const [depositCoinA] = txb.splitCoins(coin1Arg, [amounts[0]]);
-        const [depositCoinB] = txb.splitCoins(coin2Arg, [amounts[1]]);
-        const poolinfo = poolInfo[poolName];
-        let someReceipt;
-        if (receipt.length == 0) {
-            [someReceipt] = txb.moveCall({
-                target: `0x1::option::none`,
-                typeArguments: [poolinfo.receiptType],
-                arguments: [],
-            });
-        }
-        else {
-            [someReceipt] = txb.moveCall({
-                target: `0x1::option::some`,
-                typeArguments: [receipt[0].content.type],
-                arguments: [txb.object(receipt[0].objectId)],
-            });
-        }
-        if (poolName === "BLUEFIN-BLUE-SUI") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_sui_second_pool::user_deposit_v2`,
-                typeArguments: [
-                    coinsList[pool1].type,
-                    coinsList[pool2].type,
-                    coinsList["DEEP"].type,
-                    coinsList["SUI"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_4_VERSION),
-                    txb.object(getConf().VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(getConf().BLUEFIN_DEEP_SUI_POOL),
-                    txb.object(cetusPoolMap["BLUE-SUI"]),
-                    txb.object(getConf().LST_INFO),
-                    txb.object(getConf().SUI_SYSTEM_STATE),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        else if (poolName === "BLUEFIN-WBTC-SUI") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_sui_second_pool::user_deposit_v2`,
-                typeArguments: [
-                    coinsList[pool1].type,
-                    coinsList[pool2].type,
-                    coinsList["BLUE"].type,
-                    coinsList["SUI"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_4_VERSION),
-                    txb.object(getConf().VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_WBTC_SUI_POOL),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(cetusPoolMap["WBTC-SUI"]),
-                    txb.object(getConf().LST_INFO),
-                    txb.object(getConf().SUI_SYSTEM_STATE),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        else if (poolName === "BLUEFIN-DEEP-SUI") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_sui_second_pool::user_deposit_v2`,
-                typeArguments: [
-                    coinsList[pool1].type,
-                    coinsList[pool2].type,
-                    coinsList["BLUE"].type,
-                    coinsList["SUI"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_4_VERSION),
-                    txb.object(getConf().VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_DEEP_SUI_POOL),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(cetusPoolMap["DEEP-SUI"]),
-                    txb.object(getConf().LST_INFO),
-                    txb.object(getConf().SUI_SYSTEM_STATE),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        else if (poolName === "BLUEFIN-STSUI-SUI") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_stsui_sui_pool::user_deposit`,
-                typeArguments: [
-                    coinsList[pool1].type,
-                    coinsList[pool2].type,
-                    coinsList["BLUE"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_4_VERSION),
-                    txb.object(getConf().VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().BLUEFIN_STSUI_SUI_POOL),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(getConf().LST_INFO),
-                    txb.object(getConf().SUI_SYSTEM_STATE),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        else if (poolName === "BLUEFIN-AUTOBALANCE-DEEP-SUI") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_sui_second_pool::user_deposit_v2`,
-                typeArguments: [
-                    coinsList[pool1].type,
-                    coinsList[pool2].type,
-                    coinsList["BLUE"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_BLUEFIN_AUTOBALANCE_VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_DEEP_SUI_POOL),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(cetusPoolMap["DEEP-SUI"]),
-                    txb.object(getConf().LST_INFO),
-                    txb.object(getConf().SUI_SYSTEM_STATE),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        else if (poolName === "BLUEFIN-AUTOBALANCE-BLUE-SUI") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_sui_second_pool::user_deposit_v2`,
-                typeArguments: [
-                    coinsList[pool1].type,
-                    coinsList[pool2].type,
-                    coinsList["DEEP"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_BLUEFIN_AUTOBALANCE_VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(getConf().BLUEFIN_DEEP_SUI_POOL),
-                    txb.object(cetusPoolMap["BLUE-SUI"]),
-                    txb.object(getConf().LST_INFO),
-                    txb.object(getConf().SUI_SYSTEM_STATE),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        txb.transferObjects([coin1Arg, coin2Arg], address);
+    else if (poolName === "BLUEFIN-NAVX-VSUI") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_type_2_pool::user_deposit_v2`,
+            typeArguments: [
+                coinsList[pool1].type,
+                coinsList[pool2].type,
+                coinsList["BLUE"].type,
+                coinsList["SUI"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_4_VERSION),
+                txb.object(getConf().VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_NAVX_VSUI_POOL),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(cetusPoolMap["NAVX-VSUI"]),
+                txb.object(cetusPoolMap["VSUI-SUI"]),
+                txb.object(getConf().LST_INFO),
+                txb.object(getConf().SUI_SYSTEM_STATE),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
     }
-    else {
-        throw new Error(`No ${pool1} or ${pool2} Coins`);
+    else if (poolName === "BLUEFIN-BLUE-USDC") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_type_2_pool::user_deposit_v2`,
+            typeArguments: [
+                coinsList[pool1].type,
+                coinsList[pool2].type,
+                coinsList["DEEP"].type,
+                coinsList["SUI"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_4_VERSION),
+                txb.object(getConf().VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_BLUE_USDC_POOL),
+                txb.object(getConf().BLUEFIN_DEEP_SUI_POOL),
+                txb.object(cetusPoolMap["BLUE-USDC"]),
+                txb.object(cetusPoolMap["USDC-SUI"]),
+                txb.object(getConf().LST_INFO),
+                txb.object(getConf().SUI_SYSTEM_STATE),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
+    }
+    else if (poolName === "BLUEFIN-STSUI-ETH") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_type_2_pool::user_deposit`,
+            typeArguments: [
+                coinsList[pool1].type,
+                coinsList[pool2].type,
+                coinsList["BLUE"].type,
+                coinsList["SUI"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_4_VERSION),
+                txb.object(getConf().VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_STSUI_ETH_POOL),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(cetusPoolMap["STSUI-ETH"]),
+                txb.object(cetusPoolMap["ETH-SUI"]),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
+    }
+    else if (poolName === "BLUEFIN-STSUI-WSOL") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_type_2_pool::user_deposit`,
+            typeArguments: [
+                coinsList[pool1].type,
+                coinsList[pool2].type,
+                coinsList["BLUE"].type,
+                coinsList["SUI"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_4_VERSION),
+                txb.object(getConf().VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_STSUI_WSOL_POOL),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(cetusPoolMap["STSUI-WSOL"]),
+                txb.object(cetusPoolMap["WSOL-SUI"]),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
     }
     return txb;
 };
-const depositBluefinStsuiTxb = async (amountA, amountB, poolName, options, transaction = undefined, coin1Arg, coin2Arg) => {
-    const address = options.address;
-    let txb;
-    if (transaction)
-        txb = transaction;
-    else
-        txb = new Transaction();
-    poolName = poolName.toUpperCase();
+const depositBluefinSuiSecondTxb = async (txb, someReceipt, poolName, depositCoinA, depositCoinB) => {
+    const poolinfo = poolInfo[poolName];
     const pool1 = doubleAssetPoolCoinMap[poolName].coin1;
     const pool2 = doubleAssetPoolCoinMap[poolName].coin2;
-    const receipt = await getReceipts(poolName, address, true);
-    amountA = (Number(amountA) * 0.999).toString();
-    amountB = (Number(amountB) * 0.999).toString();
-    let amounts = await getAmounts(poolName, true, amountA);
-    if (amounts === undefined || amounts[0] > amountA || amounts[1] > amountB) {
-        amounts = await getAmounts(poolName, false, amountB);
+    if (poolName === "BLUEFIN-BLUE-SUI") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_sui_second_pool::user_deposit_v2`,
+            typeArguments: [
+                coinsList[pool1].type,
+                coinsList[pool2].type,
+                coinsList["DEEP"].type,
+                coinsList["SUI"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_4_VERSION),
+                txb.object(getConf().VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(getConf().BLUEFIN_DEEP_SUI_POOL),
+                txb.object(cetusPoolMap["BLUE-SUI"]),
+                txb.object(getConf().LST_INFO),
+                txb.object(getConf().SUI_SYSTEM_STATE),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
     }
-    if (amounts && coin1Arg && coin2Arg) {
-        const [depositCoinA] = txb.splitCoins(coin1Arg, [amounts[0]]);
-        const [depositCoinB] = txb.splitCoins(coin2Arg, [amounts[1]]);
-        const poolinfo = poolInfo[poolName];
-        let someReceipt;
-        if (receipt.length == 0) {
-            [someReceipt] = txb.moveCall({
-                target: `0x1::option::none`,
-                typeArguments: [poolinfo.receiptType],
-                arguments: [],
-            });
-        }
-        else {
-            [someReceipt] = txb.moveCall({
-                target: `0x1::option::some`,
-                typeArguments: [receipt[0].content.type],
-                arguments: [txb.object(receipt[0].objectId)],
-            });
-        }
-        if (poolName === "BLUEFIN-STSUI-USDC") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_stsui_first_pool::user_deposit`,
-                typeArguments: [
-                    coinsList[pool1].type,
-                    coinsList[pool2].type,
-                    coinsList["BLUE"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_STSUI_VERSION),
-                    txb.object(getConf().VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_STSUI_USDC_POOL),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(cetusPoolMap["USDC-SUI"]),
-                    txb.object(bluefinPoolMap["SUI-USDC"]),
-                    txb.object(getConf().LST_INFO),
-                    txb.object(getConf().SUI_SYSTEM_STATE),
-                    txb.pure.bool(true),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        else if (poolName === "BLUEFIN-ALPHA-STSUI") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_stsui_second_pool::user_deposit`,
-                typeArguments: [
-                    coinsList[pool1].type,
-                    coinsList[pool2].type,
-                    coinsList["BLUE"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_STSUI_VERSION),
-                    txb.object(getConf().VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_ALPHA_STSUI_POOL),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(cetusPoolMap["ALPHA-SUI"]),
-                    txb.object(bluefinPoolMap["SUI-ALPHA"]),
-                    txb.object(getConf().LST_INFO),
-                    txb.object(getConf().SUI_SYSTEM_STATE),
-                    txb.pure.bool(false),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        else if (poolName === "BLUEFIN-STSUI-WSOL") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_stsui_first_pool::user_deposit`,
-                typeArguments: [
-                    coinsList[pool1].type,
-                    coinsList[pool2].type,
-                    coinsList["BLUE"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_STSUI_VERSION),
-                    txb.object(getConf().VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_STSUI_WSOL_POOL),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(cetusPoolMap["WSOL-SUI"]),
-                    txb.object(bluefinPoolMap["SUI-WSOL"]),
-                    txb.object(getConf().LST_INFO),
-                    txb.object(getConf().SUI_SYSTEM_STATE),
-                    txb.pure.bool(false),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        else if (poolName === "BLUEFIN-STSUI-ETH") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_stsui_first_pool::user_deposit`,
-                typeArguments: [
-                    coinsList[pool1].type,
-                    coinsList[pool2].type,
-                    coinsList["BLUE"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_STSUI_VERSION),
-                    txb.object(getConf().VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_STSUI_ETH_POOL),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(cetusPoolMap["ETH-SUI"]),
-                    txb.object(bluefinPoolMap["SUI-ETH"]),
-                    txb.object(getConf().LST_INFO),
-                    txb.object(getConf().SUI_SYSTEM_STATE),
-                    txb.pure.bool(false),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        else if (poolName === "BLUEFIN-STSUI-BUCK") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_stsui_first_pool::user_deposit`,
-                typeArguments: [
-                    coinsList[pool1].type,
-                    coinsList[pool2].type,
-                    coinsList["BLUE"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_STSUI_VERSION),
-                    txb.object(getConf().VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_STSUI_BUCK_POOL),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(cetusPoolMap["BUCK-SUI"]),
-                    txb.object(bluefinPoolMap["SUI-BUCK"]),
-                    txb.object(getConf().LST_INFO),
-                    txb.object(getConf().SUI_SYSTEM_STATE),
-                    txb.pure.bool(false),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        else if (poolName === "BLUEFIN-STSUI-MUSD") {
-            txb.moveCall({
-                target: `${poolinfo.packageId}::alphafi_bluefin_stsui_first_pool::user_deposit`,
-                typeArguments: [
-                    coinsList[pool1].type,
-                    coinsList[pool2].type,
-                    coinsList["BLUE"].type,
-                ],
-                arguments: [
-                    txb.object(getConf().ALPHA_STSUI_VERSION),
-                    txb.object(getConf().VERSION),
-                    someReceipt,
-                    txb.object(poolinfo.poolId),
-                    depositCoinA,
-                    depositCoinB,
-                    txb.object(getConf().ALPHA_DISTRIBUTOR),
-                    txb.object(poolinfo.investorId),
-                    txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
-                    txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
-                    txb.object(getConf().BLUEFIN_STSUI_MUSD_POOL),
-                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
-                    txb.object(cetusPoolMap["MUSD-SUI"]),
-                    txb.object(bluefinPoolMap["SUI-MUSD"]),
-                    txb.object(getConf().LST_INFO),
-                    txb.object(getConf().SUI_SYSTEM_STATE),
-                    txb.pure.bool(true),
-                    txb.object(getConf().CLOCK_PACKAGE_ID),
-                ],
-            });
-        }
-        txb.transferObjects([coin1Arg, coin2Arg], address);
+    else if (poolName === "BLUEFIN-WBTC-SUI") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_sui_second_pool::user_deposit_v2`,
+            typeArguments: [
+                coinsList[pool1].type,
+                coinsList[pool2].type,
+                coinsList["BLUE"].type,
+                coinsList["SUI"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_4_VERSION),
+                txb.object(getConf().VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_WBTC_SUI_POOL),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(cetusPoolMap["WBTC-SUI"]),
+                txb.object(getConf().LST_INFO),
+                txb.object(getConf().SUI_SYSTEM_STATE),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
     }
-    else {
-        throw new Error(`No ${pool1} or ${pool2} Coins`);
+    else if (poolName === "BLUEFIN-DEEP-SUI") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_sui_second_pool::user_deposit_v2`,
+            typeArguments: [
+                coinsList[pool1].type,
+                coinsList[pool2].type,
+                coinsList["BLUE"].type,
+                coinsList["SUI"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_4_VERSION),
+                txb.object(getConf().VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_DEEP_SUI_POOL),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(cetusPoolMap["DEEP-SUI"]),
+                txb.object(getConf().LST_INFO),
+                txb.object(getConf().SUI_SYSTEM_STATE),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
+    }
+    else if (poolName === "BLUEFIN-STSUI-SUI") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_stsui_sui_pool::user_deposit`,
+            typeArguments: [
+                coinsList[pool1].type,
+                coinsList[pool2].type,
+                coinsList["BLUE"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_4_VERSION),
+                txb.object(getConf().VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().BLUEFIN_STSUI_SUI_POOL),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(getConf().LST_INFO),
+                txb.object(getConf().SUI_SYSTEM_STATE),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
+    }
+    else if (poolName === "BLUEFIN-AUTOBALANCE-DEEP-SUI") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_sui_second_pool::user_deposit_v2`,
+            typeArguments: [
+                coinsList[pool1].type,
+                coinsList[pool2].type,
+                coinsList["BLUE"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_BLUEFIN_AUTOBALANCE_VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_DEEP_SUI_POOL),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(cetusPoolMap["DEEP-SUI"]),
+                txb.object(getConf().LST_INFO),
+                txb.object(getConf().SUI_SYSTEM_STATE),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
+    }
+    else if (poolName === "BLUEFIN-AUTOBALANCE-BLUE-SUI") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_sui_second_pool::user_deposit_v2`,
+            typeArguments: [
+                coinsList[pool1].type,
+                coinsList[pool2].type,
+                coinsList["DEEP"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_BLUEFIN_AUTOBALANCE_VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(getConf().BLUEFIN_DEEP_SUI_POOL),
+                txb.object(cetusPoolMap["BLUE-SUI"]),
+                txb.object(getConf().LST_INFO),
+                txb.object(getConf().SUI_SYSTEM_STATE),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
+    }
+    return txb;
+};
+const depositBluefinStsuiTxb = async (txb, someReceipt, poolName, depositCoinA, depositCoinB) => {
+    const poolinfo = poolInfo[poolName];
+    const pool1 = doubleAssetPoolCoinMap[poolName].coin1;
+    const pool2 = doubleAssetPoolCoinMap[poolName].coin2;
+    if (poolName === "BLUEFIN-STSUI-USDC") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_stsui_first_pool::user_deposit`,
+            typeArguments: [
+                coinsList[pool1].type,
+                coinsList[pool2].type,
+                coinsList["BLUE"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_STSUI_VERSION),
+                txb.object(getConf().VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_STSUI_USDC_POOL),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(cetusPoolMap["USDC-SUI"]),
+                txb.object(bluefinPoolMap["SUI-USDC"]),
+                txb.object(getConf().LST_INFO),
+                txb.object(getConf().SUI_SYSTEM_STATE),
+                txb.pure.bool(true),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
+    }
+    else if (poolName === "BLUEFIN-ALPHA-STSUI") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_stsui_second_pool::user_deposit`,
+            typeArguments: [
+                coinsList[pool1].type,
+                coinsList[pool2].type,
+                coinsList["BLUE"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_STSUI_VERSION),
+                txb.object(getConf().VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_ALPHA_STSUI_POOL),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(cetusPoolMap["ALPHA-SUI"]),
+                txb.object(bluefinPoolMap["SUI-ALPHA"]),
+                txb.object(getConf().LST_INFO),
+                txb.object(getConf().SUI_SYSTEM_STATE),
+                txb.pure.bool(false),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
+    }
+    else if (poolName === "BLUEFIN-STSUI-WSOL") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_stsui_first_pool::user_deposit`,
+            typeArguments: [
+                coinsList[pool1].type,
+                coinsList[pool2].type,
+                coinsList["BLUE"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_STSUI_VERSION),
+                txb.object(getConf().VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_STSUI_WSOL_POOL),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(cetusPoolMap["WSOL-SUI"]),
+                txb.object(bluefinPoolMap["SUI-WSOL"]),
+                txb.object(getConf().LST_INFO),
+                txb.object(getConf().SUI_SYSTEM_STATE),
+                txb.pure.bool(false),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
+    }
+    else if (poolName === "BLUEFIN-STSUI-ETH") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_stsui_first_pool::user_deposit`,
+            typeArguments: [
+                coinsList[pool1].type,
+                coinsList[pool2].type,
+                coinsList["BLUE"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_STSUI_VERSION),
+                txb.object(getConf().VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_STSUI_ETH_POOL),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(cetusPoolMap["ETH-SUI"]),
+                txb.object(bluefinPoolMap["SUI-ETH"]),
+                txb.object(getConf().LST_INFO),
+                txb.object(getConf().SUI_SYSTEM_STATE),
+                txb.pure.bool(false),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
+    }
+    else if (poolName === "BLUEFIN-STSUI-BUCK") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_stsui_first_pool::user_deposit`,
+            typeArguments: [
+                coinsList[pool1].type,
+                coinsList[pool2].type,
+                coinsList["BLUE"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_STSUI_VERSION),
+                txb.object(getConf().VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_STSUI_BUCK_POOL),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(cetusPoolMap["BUCK-SUI"]),
+                txb.object(bluefinPoolMap["SUI-BUCK"]),
+                txb.object(getConf().LST_INFO),
+                txb.object(getConf().SUI_SYSTEM_STATE),
+                txb.pure.bool(false),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
+    }
+    else if (poolName === "BLUEFIN-STSUI-MUSD") {
+        txb.moveCall({
+            target: `${poolinfo.packageId}::alphafi_bluefin_stsui_first_pool::user_deposit`,
+            typeArguments: [
+                coinsList[pool1].type,
+                coinsList[pool2].type,
+                coinsList["BLUE"].type,
+            ],
+            arguments: [
+                txb.object(getConf().ALPHA_STSUI_VERSION),
+                txb.object(getConf().VERSION),
+                someReceipt,
+                txb.object(poolinfo.poolId),
+                depositCoinA,
+                depositCoinB,
+                txb.object(getConf().ALPHA_DISTRIBUTOR),
+                txb.object(poolinfo.investorId),
+                txb.object(getConf().BLUEFIN_GLOBAL_CONFIG),
+                txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
+                txb.object(getConf().BLUEFIN_STSUI_MUSD_POOL),
+                txb.object(getConf().BLUEFIN_BLUE_SUI_POOL),
+                txb.object(cetusPoolMap["MUSD-SUI"]),
+                txb.object(bluefinPoolMap["SUI-MUSD"]),
+                txb.object(getConf().LST_INFO),
+                txb.object(getConf().SUI_SYSTEM_STATE),
+                txb.pure.bool(true),
+                txb.object(getConf().CLOCK_PACKAGE_ID),
+            ],
+        });
     }
     return txb;
 };
-export async function getZapAmounts(inputCoinAmount, inputCoinName, poolName, slippage, options, ignoreCache) {
-    const address = options.address;
+export async function getZapAmounts(inputCoinAmount, inputCoinName, poolName, slippage, address, ignoreCache) {
     const coinTypeA = doubleAssetPoolCoinMap[poolName].coin1;
     const coinTypeB = doubleAssetPoolCoinMap[poolName].coin2;
     const swapObjectA = coinsList[coinTypeA];
     const swapObjectB = coinsList[coinTypeB];
     const inputObject = coinsList[inputCoinName];
     const amounts = await getAmounts(poolName, true, "100000001");
-    if (amounts) {
-        const amount1 = Number(amounts[0]);
-        const amount2 = Number(amounts[1]);
-        const swapGateway = new SevenKGateway();
-        const swapOptions = {
-            pair: {
-                coinA: swapObjectA,
-                coinB: swapObjectB,
-            },
-            senderAddress: address,
-            inAmount: new BN(amount1),
-            slippage: slippage,
-        };
-        const ratioQuote = await zapGetQuote(swapGateway, swapOptions, poolName);
-        if (ratioQuote) {
-            const amount1InCoinType2 = Number(ratioQuote);
-            const totalAmount = amount2 + amount1InCoinType2;
-            const inputAmountToType1 = Math.floor((inputCoinAmount * amount1InCoinType2) / totalAmount);
-            const inputAmountToType2 = Math.floor((inputCoinAmount * amount2) / totalAmount);
-            let amountA, amountB;
-            const swapOptionsI2A = {
-                pair: {
-                    coinA: inputObject,
-                    coinB: swapObjectA,
-                },
-                senderAddress: address,
-                inAmount: new BN(inputAmountToType1),
-                slippage: slippage,
-            };
-            const swapOptionsI2B = {
-                pair: {
-                    coinA: inputObject,
-                    coinB: swapObjectB,
-                },
-                senderAddress: address,
-                inAmount: new BN(inputAmountToType2),
-                slippage: slippage,
-            };
-            if (inputCoinName === coinTypeA) {
-                amountB = await zapGetQuote(swapGateway, swapOptionsI2B, poolName);
-                amountA = inputAmountToType1.toString();
-            }
-            else if (inputCoinName === coinTypeB) {
-                amountA = await zapGetQuote(swapGateway, swapOptionsI2A, poolName);
-                amountB = inputAmountToType2.toString();
-            }
-            else {
-                amountA = await zapGetQuote(swapGateway, swapOptionsI2A, poolName);
-                amountB = await zapGetQuote(swapGateway, swapOptionsI2B, poolName);
-            }
-            if (amountA && amountB) {
-                const [coin1Price, coin2Price] = await getLatestPrices([
-                    `${swapObjectA.name}/USD`,
-                    `${swapObjectB.name}/USD`,
-                ], ignoreCache);
-                const coin1InUSD = Number(amountA) * Number(coin1Price);
-                const coin2InUSD = Number(amountB) * Number(coin2Price);
-                return [
-                    amountA.toString(),
-                    coin1InUSD.toString(),
-                    amountB.toString(),
-                    coin2InUSD.toString(),
-                ];
-            }
-        }
+    const amount1 = Number(amounts[0]);
+    const amount2 = Number(amounts[1]);
+    const swapGateway = new SevenKGateway();
+    const swapOptions = {
+        pair: {
+            coinA: swapObjectA,
+            coinB: swapObjectB,
+        },
+        senderAddress: address,
+        inAmount: new BN(amount1),
+        slippage: slippage,
+    };
+    const ratioQuote = await zapGetQuote(swapGateway, swapOptions, poolName);
+    if (!ratioQuote) {
+        console.error(`Error geting quote for zap`);
+        return undefined;
+    }
+    const amount1InCoinType2 = Number(ratioQuote);
+    const totalAmount = amount2 + amount1InCoinType2;
+    const inputAmountToType1 = Math.floor((inputCoinAmount * amount1InCoinType2) / totalAmount);
+    const inputAmountToType2 = Math.floor((inputCoinAmount * amount2) / totalAmount);
+    let amountA, amountB;
+    const swapOptionsI2A = {
+        pair: {
+            coinA: inputObject,
+            coinB: swapObjectA,
+        },
+        senderAddress: address,
+        inAmount: new BN(inputAmountToType1),
+        slippage: slippage,
+    };
+    const swapOptionsI2B = {
+        pair: {
+            coinA: inputObject,
+            coinB: swapObjectB,
+        },
+        senderAddress: address,
+        inAmount: new BN(inputAmountToType2),
+        slippage: slippage,
+    };
+    if (inputCoinName === coinTypeA) {
+        amountA = inputAmountToType1.toString();
+        amountB = await zapGetQuote(swapGateway, swapOptionsI2B, poolName);
+    }
+    else if (inputCoinName === coinTypeB) {
+        amountA = await zapGetQuote(swapGateway, swapOptionsI2A, poolName);
+        amountB = inputAmountToType2.toString();
+    }
+    else {
+        amountA = await zapGetQuote(swapGateway, swapOptionsI2A, poolName);
+        amountB = await zapGetQuote(swapGateway, swapOptionsI2B, poolName);
+    }
+    if (amountA && amountB) {
+        const [coin1Price, coin2Price] = await getLatestPrices([
+            `${swapObjectA.name}/USD`,
+            `${swapObjectB.name}/USD`,
+        ], ignoreCache);
+        const coin1InUSD = Number(amountA) * Number(coin1Price);
+        const coin2InUSD = Number(amountB) * Number(coin2Price);
+        return [
+            amountA.toString(),
+            coin1InUSD.toString(),
+            amountB.toString(),
+            coin2InUSD.toString(),
+        ];
     }
 }
-// export async function zapWithdraw(
-//   amount: string,
-//   poolName: PoolName,
-//   outputCoinName: string,
-//   options: { suiClient: SuiClient; address: string },
-// ) {
-//   const suiClient = options.suiClient;
-//   const address = options.address;
-//   const txb = new Transaction();
-//   const pool1 = doubleAssetPoolCoinMap[poolName].pool1;
-//   const pool2 = doubleAssetPoolCoinMap[poolName].pool2;
-// }
-//calculate ratio of both coins in terms of coin-type 2
-//convert outputAmount in coinType2
-//then calculate coinType1 and coinType2 based on previous ratio
-//convert those amounts to liquidity
-//pass that liquidity into cetusWithdrawTxb
-//swap the amount withdrawn to outputAmountType.
 //# sourceMappingURL=zapDeposit.js.map