@alphafi/alphafi-sdk 0.0.52 → 0.0.54

package/dist/esm/transactions/zapDeposit.js

@@ -20,149 +20,222 @@ options) {
     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) {
-        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);
-        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 = {
+    if (!amounts) {
+        console.error("Error fetching amounts 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;
+        }
+        else {
+            const swapOptionsI2B = {
                 pair: {
                     coinA: inputObject,
-                    coinB: swapObjectA,
+                    coinB: swapObjectB,
                 },
                 senderAddress: address,
-                inAmount: new BN(inputAmountToType1),
+                inAmount: new BN(inputCoinAmount),
                 slippage: slippage,
             };
-            const swapOptionsI2B = {
+            const result = await zapSwap(swapOptionsI2B, txb);
+            if (result) {
+                amountB = result.amountOut;
+                txb = result.tx;
+                if (result.coinOut) {
+                    coin2 = result.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 {
+            const swapOptionsI2A = {
                 pair: {
                     coinA: inputObject,
-                    coinB: swapObjectB,
+                    coinB: swapObjectA,
                 },
                 senderAddress: address,
-                inAmount: new BN(inputAmountToType2),
+                inAmount: new BN(inputCoinAmount),
                 slippage: slippage,
             };
-            if (inputCoinName === coinTypeA) {
-                const result = await zapSwap(swapOptionsI2B, txb);
-                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;
+            const result = await zapSwap(swapOptionsI2A, txb);
+            if (result) {
+                amountA = result.amountOut;
+                txb = result.tx;
+                if (result.coinOut) {
+                    coin1 = result.coinOut;
                 }
             }
-            else if (inputCoinName === coinTypeB) {
-                const result = await zapSwap(swapOptionsI2A, txb);
-                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 {
+        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);
+        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);
+            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 {
-                let result = await zapSwap(swapOptionsI2A, txb);
-                if (result) {
-                    amountA = result.amountOut;
-                    txb = result.tx;
-                    if (result.coinOut) {
-                        coin1 = result.coinOut;
-                    }
-                }
-                result = await zapSwap(swapOptionsI2B, txb);
-                if (result) {
-                    amountB = result.amountOut;
-                    txb = result.tx;
-                    if (result.coinOut) {
-                        coin2 = result.coinOut;
-                    }
+                const res = await splitFromExisting(coinTypeA, amountA, txb, suiClient, address);
+                txb = res.tx;
+                coin1 = res.coinOut;
+            }
+        }
+        else if (inputCoinName === coinTypeB) {
+            const result = await zapSwap(swapOptionsI2A, txb);
+            if (result) {
+                amountA = result.amountOut;
+                txb = result.tx;
+                if (result.coinOut) {
+                    coin1 = result.coinOut;
                 }
             }
-            if (amountA && amountB && coin1 && coin2) {
-                // 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 pool1 = doubleAssetPoolCoinMap[poolName].coin1;
-                const pool2 = doubleAssetPoolCoinMap[poolName].coin2;
-                if (poolInfo[poolName].parentProtocolName === "CETUS") {
-                    if (pool1 === "CETUS" && pool2 === "SUI") {
-                        txb = await depositCetusSuiTxb(amountA, amountB, poolName, { address }, txb, coin1, coin2);
-                    }
-                    else if (pool2 === "SUI") {
-                        txb = await depositCetusAlphaSuiTxb(amountA, amountB, poolName, { address }, txb, coin1, coin2);
-                    }
-                    else {
-                        txb = await depositCetus(amountA, amountB, poolName, { address }, txb, coin1, coin2);
-                    }
+            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);
+            if (result) {
+                amountA = result.amountOut;
+                txb = result.tx;
+                if (result.coinOut) {
+                    coin1 = result.coinOut;
                 }
-                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);
-                    }
-                    else if (pool1 === "SUI") {
-                        txb = await depositBluefinSuiFirstTxb(amountA, amountB, poolName, { address }, txb, coin1, coin2);
-                    }
-                    else if (pool2 === "SUI") {
-                        txb = await depositBluefinSuiSecondTxb(amountA, amountB, poolName, { address }, txb, coin1, coin2);
-                    }
-                    else if (pool1 === "STSUI" || pool2 === "STSUI") {
-                        txb = await depositBluefinStsuiTxb(amountA, amountB, poolName, { address }, txb, coin1, coin2);
-                    }
-                    else {
-                        txb = await depositBluefinType1Txb(amountA, amountB, poolName, { address }, txb, coin1, coin2);
-                    }
+            }
+            result = await zapSwap(swapOptionsI2B, txb);
+            if (result) {
+                amountB = result.amountOut;
+                txb = result.tx;
+                if (result.coinOut) {
+                    coin2 = result.coinOut;
                 }
             }
-            txb.setGasBudget(100000000);
-            return txb;
         }
     }
-    return undefined;
+    if (amountA && amountB && coin1 && coin2) {
+        // 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 pool1 = doubleAssetPoolCoinMap[poolName].coin1;
+        const pool2 = doubleAssetPoolCoinMap[poolName].coin2;
+        amountA = (Number(amountA) * 0.999).toString();
+        amountB = (Number(amountB) * 0.999).toString();
+        if (poolInfo[poolName].parentProtocolName === "CETUS") {
+            if (pool1 === "CETUS" && pool2 === "SUI") {
+                txb = await depositCetusSuiTxb(amountA, amountB, poolName, { address }, txb, coin1, coin2);
+            }
+            else if (pool2 === "SUI") {
+                txb = await depositCetusAlphaSuiTxb(amountA, amountB, poolName, { address }, txb, coin1, coin2);
+            }
+            else {
+                txb = await depositCetus(amountA, amountB, poolName, { address }, txb, coin1, coin2);
+            }
+        }
+        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);
+            }
+            else if (pool1 === "SUI") {
+                txb = await depositBluefinSuiFirstTxb(amountA, amountB, poolName, { address }, txb, coin1, coin2);
+            }
+            else if (pool2 === "SUI") {
+                txb = await depositBluefinSuiSecondTxb(amountA, amountB, poolName, { address }, txb, coin1, coin2);
+            }
+            else if (pool1 === "STSUI" || pool2 === "STSUI") {
+                txb = await depositBluefinStsuiTxb(amountA, amountB, poolName, { address }, txb, coin1, coin2);
+            }
+            else {
+                txb = await depositBluefinType1Txb(amountA, amountB, poolName, { address }, txb, coin1, coin2);
+            }
+        }
+    }
+    txb.setGasBudget(100000000);
+    return txb;
 }
 async function zapGetQuote(swapGateway, swapOptions) {
     if (swapOptions.pair.coinA.name === "SUI" &&
@@ -189,6 +262,7 @@ async function zapGetQuote(swapGateway, swapOptions) {
 async function zapSwap(swapOptions, txb) {
     if (swapOptions.pair.coinA.name === "SUI" &&
         swapOptions.pair.coinB.name === "STSUI") {
+        console.log("mintTx called");
         const result = await mintTx(swapOptions.inAmount ? swapOptions.inAmount.toString() : "0", txb);
         return {
             tx: result.tx,
@@ -199,10 +273,12 @@ async function zapSwap(swapOptions, txb) {
     }
     else if (swapOptions.pair.coinA.name === "STSUI" &&
         swapOptions.pair.coinB.name === "SUI") {
+        console.log("redeemTx called");
         const result = await redeemTx(swapOptions.inAmount ? swapOptions.inAmount.toString() : "0", txb, { address: swapOptions.senderAddress });
         return result;
     }
     else {
+        console.log("7k swap", swapOptions);
         const swapGateway = new SevenKGateway();
         const quoteResponse = await swapGateway.getQuote(swapOptions);
         if (quoteResponse) {
@@ -372,7 +448,7 @@ const depositCetusAlphaSuiTxb = async (amountA, amountB, poolName, options, tran
             });
         }
         txb.moveCall({
-            target: `${getConf().ALPHA_LATEST_PACKAGE_ID}::alphafi_cetus_sui_pool::user_deposit`,
+            target: `${poolinfo.packageId}::alphafi_cetus_sui_pool::user_deposit`,
             typeArguments: [coinsList[pool1].type, coinsList[pool2].type],
             arguments: [
                 txb.object(getConf().VERSION),
@@ -385,7 +461,7 @@ const depositCetusAlphaSuiTxb = async (amountA, amountB, poolName, options, tran
                 txb.object(getConf().CETUS_GLOBAL_CONFIG_ID),
                 txb.object(getConf().CETUS_REWARDER_GLOBAL_VAULT_ID),
                 txb.object(cetusPoolMap["CETUS-SUI"]),
-                txb.object(poolinfo.parentPoolId),
+                txb.object(cetusPoolMap[poolName]),
                 txb.object(getConf().CLOCK_PACKAGE_ID),
             ],
         });
@@ -574,6 +650,32 @@ const depositBluefinSuiFirstTxb = async (amountA, amountB, poolName, options, tr
                 ],
             });
         }
+        else if (poolName === "BLUEFIN-AUTOBALANCE-SUI-USDC") {
+            txb.moveCall({
+                target: `${poolinfo.packageId}::alphafi_bluefin_sui_first_pool::user_deposit`,
+                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_AUTOCOMPOUND),
+                    txb.object(cetusPoolMap["USDC-SUI"]),
+                    txb.object(getConf().CLOCK_PACKAGE_ID),
+                ],
+            });
+        }
         txb.transferObjects([coin1Arg, coin2Arg], address);
     }
     else {
@@ -729,6 +831,143 @@ const depositBluefinType1Txb = async (amountA, amountB, poolName, options, trans
                 ],
             });
         }
+        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_AUTOCOMPOUND),
+                    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`,
+                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_AUTOCOMPOUND),
+                    txb.object(cetusPoolMap["USDC-USDT"]),
+                    txb.object(cetusPoolMap["USDC-SUI"]),
+                    txb.object(getConf().CLOCK_PACKAGE_ID),
+                ],
+            });
+        }
+        else if (poolName === "BLUEFIN-SUIUSDT-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_SUIUSDT_USDC_POOL),
+                    txb.object(getConf().BLUEFIN_BLUE_SUI_POOL_AUTOCOMPOUND),
+                    txb.object(cetusPoolMap["USDC-SUIUSDT"]),
+                    txb.object(cetusPoolMap["USDC-SUI"]),
+                    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`,
+                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_AUTOCOMPOUND),
+                    txb.object(cetusPoolMap["USDC-SUIUSDT"]),
+                    txb.object(cetusPoolMap["USDC-SUI"]),
+                    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`,
+                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_AUTOCOMPOUND),
+                    txb.object(cetusPoolMap["BLUE-DEEP"]),
+                    txb.object(cetusPoolMap["BLUE-SUI"]),
+                    txb.object(getConf().CLOCK_PACKAGE_ID),
+                ],
+            });
+        }
         txb.transferObjects([coin1Arg, coin2Arg], address);
     }
     else {
@@ -856,6 +1095,62 @@ const depositBluefinType2Txb = async (amountA, amountB, poolName, options, trans
                 ],
             });
         }
+        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 {