@typus/typus-sdk 1.7.13 → 1.7.14

package/dist/src/auto-bid/user-entry.js

@@ -20,6 +20,7 @@ exports.getNewStrategyTx = getNewStrategyTx;
 exports.getCloseStrategyTx = getCloseStrategyTx;
 exports.getWithdrawProfitStrategyTx = getWithdrawProfitStrategyTx;
 exports.getUpdateStrategyTx = getUpdateStrategyTx;
+var utils_1 = require("../../src/utils");
 /**
     entry fun new_strategy<B_TOKEN>(
         strategy_pool: &mut StrategyPool,
@@ -34,49 +35,22 @@ exports.getUpdateStrategyTx = getUpdateStrategyTx;
     )
 */
 function getNewStrategyTx(config, tx, input) {
-    if (
-    // B_TOKEN
-    input.typeArguments[1] == "0x2::sui::SUI" ||
-        input.typeArguments[1] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI") {
-        var _a = __read(tx.splitCoins(tx.gas, [tx.pure.u64(input.amount)]), 1), input_coin = _a[0];
-        tx.moveCall({
-            target: "".concat(config.package.dovSingle, "::auto_bid::new_strategy"),
-            typeArguments: input.typeArguments,
-            arguments: [
-                tx.object(config.registry.dov.dovSingle),
-                tx.object(config.registry.dov.autoBid),
-                tx.pure.u64(input.vaultIndex),
-                tx.pure.u64(input.signalIndex),
-                tx.pure.u64(input.size),
-                tx.pure.u64(input.pricePercentage),
-                tx.pure.u64(input.maxTimes),
-                tx.pure.vector("u64", input.targetRounds),
-                input_coin,
-            ],
-        });
-    }
-    else {
-        var coin = input.coins.pop();
-        if (input.coins.length > 0) {
-            tx.mergeCoins(tx.object(coin), input.coins.map(function (coin) { return tx.object(coin); }));
-        }
-        var _b = __read(tx.splitCoins(tx.object(coin), [tx.pure.u64(input.amount)]), 1), input_coin = _b[0];
-        tx.moveCall({
-            target: "".concat(config.package.dovSingle, "::auto_bid::new_strategy"),
-            typeArguments: input.typeArguments,
-            arguments: [
-                tx.object(config.registry.dov.dovSingle),
-                tx.object(config.registry.dov.autoBid),
-                tx.pure.u64(input.vaultIndex),
-                tx.pure.u64(input.signalIndex),
-                tx.pure.u64(input.size),
-                tx.pure.u64(input.pricePercentage),
-                tx.pure.u64(input.maxTimes),
-                tx.pure.vector("u64", input.targetRounds),
-                input_coin,
-            ],
-        });
-    }
+    var input_coin = (0, utils_1.splitCoins)(tx, input.typeArguments[1], input.coins, input.amount, config.sponsored);
+    tx.moveCall({
+        target: "".concat(config.package.dovSingle, "::auto_bid::new_strategy"),
+        typeArguments: input.typeArguments,
+        arguments: [
+            tx.object(config.registry.dov.dovSingle),
+            tx.object(config.registry.dov.autoBid),
+            tx.pure.u64(input.vaultIndex),
+            tx.pure.u64(input.signalIndex),
+            tx.pure.u64(input.size),
+            tx.pure.u64(input.pricePercentage),
+            tx.pure.u64(input.maxTimes),
+            tx.pure.vector("u64", input.targetRounds),
+            input_coin,
+        ],
+    });
     return tx;
 }
 /**
@@ -133,70 +107,22 @@ function getWithdrawProfitStrategyTx(config, tx, input) {
     )
 */
 function getUpdateStrategyTx(config, tx, input) {
-    if (
-    // B_TOKEN
-    input.typeArguments[1] == "0x2::sui::SUI" ||
-        input.typeArguments[1] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI") {
-        if (input.amount) {
-            var _a = __read(tx.splitCoins(tx.gas, [tx.pure.u64(input.amount)]), 1), input_coin = _a[0];
-            tx.moveCall({
-                target: "".concat(config.package.dovSingle, "::auto_bid::update_strategy"),
-                typeArguments: input.typeArguments,
-                arguments: [
-                    tx.object(config.registry.dov.dovSingle),
-                    tx.object(config.registry.dov.autoBid),
-                    tx.pure.u64(input.vaultIndex),
-                    tx.pure.u64(input.signalIndex),
-                    tx.pure.u64(input.strategyIndex),
-                    tx.pure.option("u64", input.size),
-                    tx.pure.option("u64", input.pricePercentage),
-                    tx.pure.option("u64", input.maxTimes),
-                    tx.pure.vector("u64", input.targetRounds),
-                    tx.makeMoveVec({ elements: [input_coin] }),
-                ],
-            });
-        }
-        else {
-            tx.moveCall({
-                target: "".concat(config.package.dovSingle, "::auto_bid::update_strategy"),
-                typeArguments: input.typeArguments,
-                arguments: [
-                    tx.object(config.registry.dov.dovSingle),
-                    tx.object(config.registry.dov.autoBid),
-                    tx.pure.u64(input.vaultIndex),
-                    tx.pure.u64(input.signalIndex),
-                    tx.pure.u64(input.strategyIndex),
-                    tx.pure.option("u64", input.size),
-                    tx.pure.option("u64", input.pricePercentage),
-                    tx.pure.option("u64", input.maxTimes),
-                    tx.pure.vector("u64", input.targetRounds),
-                    tx.makeMoveVec({ elements: [] }),
-                ],
-            });
-        }
-    }
-    else {
-        var coin = input.coins.pop();
-        if (input.coins.length > 0) {
-            tx.mergeCoins(tx.object(coin), input.coins.map(function (coin) { return tx.object(coin); }));
-        }
-        var _b = __read(tx.splitCoins(tx.object(coin), [tx.pure.u64(input.amount)]), 1), input_coin = _b[0];
-        tx.moveCall({
-            target: "".concat(config.package.dovSingle, "::auto_bid::update_strategy"),
-            typeArguments: input.typeArguments,
-            arguments: [
-                tx.object(config.registry.dov.dovSingle),
-                tx.object(config.registry.dov.autoBid),
-                tx.pure.u64(input.vaultIndex),
-                tx.pure.u64(input.signalIndex),
-                tx.pure.u64(input.strategyIndex),
-                tx.pure.option("u64", input.size),
-                tx.pure.option("u64", input.pricePercentage),
-                tx.pure.option("u64", input.maxTimes),
-                tx.pure.vector("u64", input.targetRounds),
-                tx.makeMoveVec({ elements: [input_coin] }),
-            ],
-        });
-    }
+    var input_coin = (0, utils_1.splitCoins)(tx, input.typeArguments[1], input.coins, input.amount, config.sponsored);
+    tx.moveCall({
+        target: "".concat(config.package.dovSingle, "::auto_bid::update_strategy"),
+        typeArguments: input.typeArguments,
+        arguments: [
+            tx.object(config.registry.dov.dovSingle),
+            tx.object(config.registry.dov.autoBid),
+            tx.pure.u64(input.vaultIndex),
+            tx.pure.u64(input.signalIndex),
+            tx.pure.u64(input.strategyIndex),
+            tx.pure.option("u64", input.size),
+            tx.pure.option("u64", input.pricePercentage),
+            tx.pure.option("u64", input.maxTimes),
+            tx.pure.vector("u64", input.targetRounds),
+            tx.makeMoveVec({ elements: [input_coin] }),
+        ],
+    });
     return tx;
 }

package/dist/src/dice/user-entry.js

@@ -83,7 +83,7 @@ function newGameTx(config, tx, input) {
                 default:
                     break;
             }
-            coin = (0, utils_1.splitCoins)(tx, input.typeArguments[0], input.coins, input.amount);
+            coin = (0, utils_1.splitCoins)(tx, input.typeArguments[0], input.coins, input.amount, false);
             tx.moveCall({
                 target: "".concat(config.package.dice, "::").concat(input.module, "::new_game"),
                 typeArguments: input.typeArguments,
@@ -151,7 +151,7 @@ function newGamePlayGuessTx(config, tx, input) {
                 default:
                     break;
             }
-            coin = (0, utils_1.splitCoins)(tx, input.typeArguments[0], input.coins, input.amount);
+            coin = (0, utils_1.splitCoins)(tx, input.typeArguments[0], input.coins, input.amount, false);
             tx.moveCall({
                 target: "".concat(config.package.dice, "::").concat(input.module, "::new_game"),
                 typeArguments: input.typeArguments,
@@ -234,7 +234,7 @@ function playTx(config, tx, input) {
                 default:
                     break;
             }
-            coin = (0, utils_1.splitCoins)(tx, input.typeArguments[0], input.coins, input.amount);
+            coin = (0, utils_1.splitCoins)(tx, input.typeArguments[0], input.coins, input.amount, false);
             tx.moveCall({
                 target: "".concat(config.package.dice, "::").concat(input.module, "::play"),
                 typeArguments: input.typeArguments,

package/dist/src/typus/airdrop/authority-entry.js

@@ -35,25 +35,10 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRemoveAirdropTx = getRemoveAirdropTx;
 exports.getSetAirdropTx = getSetAirdropTx;
+var utils_1 = require("../../../src/utils");
 /**
     public fun remove_airdrop<TOKEN>(
         version: &Version,
@@ -94,38 +79,21 @@ function getRemoveAirdropTx(config, tx, input) {
 */
 function getSetAirdropTx(config, tx, input) {
     return __awaiter(this, void 0, void 0, function () {
-        var _a, coin;
-        return __generator(this, function (_b) {
-            if (input.typeArguments[0] == "0x2::sui::SUI" ||
-                input.typeArguments[0] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI") {
-                _a = __read(tx.splitCoins(tx.gas, [tx.pure.u64(input.amount)]), 1), coin = _a[0];
-                tx.moveCall({
-                    target: "".concat(config.package.typus, "::airdrop::set_airdrop"),
-                    typeArguments: input.typeArguments,
-                    arguments: [
-                        tx.object(config.version.typus),
-                        tx.object(config.registry.typus.airdrop),
-                        tx.pure.string(input.key),
-                        tx.makeMoveVec({ elements: [coin] }),
-                        tx.pure.vector("address", input.users),
-                        tx.pure.vector("u64", input.values),
-                    ],
-                });
-            }
-            else {
-                tx.moveCall({
-                    target: "".concat(config.package.typus, "::airdrop::set_airdrop"),
-                    typeArguments: input.typeArguments,
-                    arguments: [
-                        tx.object(config.version.typus),
-                        tx.object(config.registry.typus.airdrop),
-                        tx.pure.string(input.key),
-                        tx.makeMoveVec({ elements: input.coins.map(function (id) { return tx.object(id); }) }),
-                        tx.pure.vector("address", input.users),
-                        tx.pure.vector("u64", input.values),
-                    ],
-                });
-            }
+        var coin;
+        return __generator(this, function (_a) {
+            coin = (0, utils_1.splitCoins)(tx, input.typeArguments[0], input.coins, input.amount);
+            tx.moveCall({
+                target: "".concat(config.package.typus, "::airdrop::set_airdrop"),
+                typeArguments: input.typeArguments,
+                arguments: [
+                    tx.object(config.version.typus),
+                    tx.object(config.registry.typus.airdrop),
+                    tx.pure.string(input.key),
+                    tx.makeMoveVec({ elements: [coin] }),
+                    tx.pure.vector("address", input.users),
+                    tx.pure.vector("u64", input.values),
+                ],
+            });
             return [2 /*return*/, tx];
         });
     });

package/dist/src/typus-dov-single-v2/otc-entry.js

@@ -108,7 +108,7 @@ function otc(config, tx, input) {
     return __awaiter(this, void 0, void 0, function () {
         var coin, balance;
         return __generator(this, function (_a) {
-            coin = (0, utils_1.splitCoins)(tx, input.typeArguments[1], input.coins, input.amount);
+            coin = (0, utils_1.splitCoins)(tx, input.typeArguments[1], input.coins, input.amount, config.sponsored);
             balance = tx.moveCall({
                 target: "0x2::coin::into_balance",
                 typeArguments: [input.typeArguments[1]],

package/dist/src/typus-dov-single-v2/user-entry.js

@@ -1,20 +1,4 @@
 "use strict";
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRaiseFundTx = getRaiseFundTx;
 exports.getReduceFundTx = getReduceFundTx;
@@ -45,7 +29,7 @@ var utils_1 = require("../../src/utils");
     ): (TypusDepositReceipt, vector<u64>) {
  */
 function getRaiseFundTx(config, tx, input) {
-    var coin = (0, utils_1.splitCoins)(tx, input.typeArguments[0], input.raiseCoins, input.raiseAmount);
+    var coin = (0, utils_1.splitCoins)(tx, input.typeArguments[0], input.raiseCoins, input.raiseAmount, config.sponsored);
     var raiseBalance = tx.moveCall({
         target: "0x2::coin::into_balance",
         typeArguments: [input.typeArguments[0]],
@@ -176,56 +160,28 @@ function getRefreshDepositSnapshotTx(config, tx, input) {
     )
 */
 function getNewBidTx(config, tx, input) {
-    if (!input.usingSponsoredGasCoin &&
-        (input.typeArguments[1] == "0x2::sui::SUI" ||
-            input.typeArguments[1] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI")) {
-        var _a = __read(tx.splitCoins(tx.gas, [tx.pure.u64(input.premium_required)]), 1), coin = _a[0];
-        var result = tx.moveCall({
-            target: "".concat(config.package.dovSingle, "::tds_user_entry::public_bid"),
-            typeArguments: input.typeArguments,
-            arguments: [
-                tx.object(config.version.typus),
-                tx.object(config.registry.typus.user),
-                tx.object(config.registry.typus.tgld),
-                tx.object(config.registry.typus.leaderboard),
-                tx.object(config.registry.dov.dovSingle),
-                tx.pure.u64(input.index),
-                tx.makeMoveVec({ elements: [coin] }),
-                tx.pure.u64(input.size),
-                tx.object(constants_1.CLOCK),
-            ],
-        });
-        tx.transferObjects([tx.object(result[0])], input.user);
-        tx.moveCall({
-            target: "".concat(config.package.framework, "::utils::transfer_coins"),
-            typeArguments: [input.typeArguments[1]],
-            arguments: [tx.makeMoveVec({ elements: [tx.object(result[1])] }), tx.pure.address(input.user)],
-        });
-    }
-    else {
-        var coin = (0, utils_1.splitCoins)(tx, input.typeArguments[1], input.coins, input.premium_required);
-        var result = tx.moveCall({
-            target: "".concat(config.package.dovSingle, "::tds_user_entry::public_bid"),
-            typeArguments: input.typeArguments,
-            arguments: [
-                tx.object(config.version.typus),
-                tx.object(config.registry.typus.user),
-                tx.object(config.registry.typus.tgld),
-                tx.object(config.registry.typus.leaderboard),
-                tx.object(config.registry.dov.dovSingle),
-                tx.pure.u64(input.index),
-                tx.makeMoveVec({ elements: [coin] }),
-                tx.pure.u64(input.size),
-                tx.object(constants_1.CLOCK),
-            ],
-        });
-        tx.transferObjects([tx.object(result[0])], input.user);
-        tx.moveCall({
-            target: "".concat(config.package.framework, "::utils::transfer_coins"),
-            typeArguments: [input.typeArguments[1]],
-            arguments: [tx.makeMoveVec({ elements: [tx.object(result[1])] }), tx.pure.address(input.user)],
-        });
-    }
+    var coin = (0, utils_1.splitCoins)(tx, input.typeArguments[1], input.coins, input.premium_required, config.sponsored);
+    var result = tx.moveCall({
+        target: "".concat(config.package.dovSingle, "::tds_user_entry::public_bid"),
+        typeArguments: input.typeArguments,
+        arguments: [
+            tx.object(config.version.typus),
+            tx.object(config.registry.typus.user),
+            tx.object(config.registry.typus.tgld),
+            tx.object(config.registry.typus.leaderboard),
+            tx.object(config.registry.dov.dovSingle),
+            tx.pure.u64(input.index),
+            tx.makeMoveVec({ elements: [coin] }),
+            tx.pure.u64(input.size),
+            tx.object(constants_1.CLOCK),
+        ],
+    });
+    tx.transferObjects([tx.object(result[0])], input.user);
+    tx.moveCall({
+        target: "".concat(config.package.framework, "::utils::transfer_coins"),
+        typeArguments: [input.typeArguments[1]],
+        arguments: [tx.makeMoveVec({ elements: [tx.object(result[1])] }), tx.pure.address(input.user)],
+    });
     return tx;
 }
 /**

package/dist/src/typus-hedge/user-entry.js

@@ -40,8 +40,8 @@ var utils_2 = require("../../src/utils");
     ) {
  */
 function raiseFund(config, tx, input) {
-    var mainCoin = (0, utils_2.splitCoins)(tx, input.typeArguments[0], input.raiseMainCoins, input.raiseMainAmount);
-    var hedgeCoin = (0, utils_2.splitCoins)(tx, input.typeArguments[1], input.raiseHedgeCoins, input.raiseHedgeAmount);
+    var mainCoin = (0, utils_2.splitCoins)(tx, input.typeArguments[0], input.raiseMainCoins, input.raiseMainAmount, config.sponsored);
+    var hedgeCoin = (0, utils_2.splitCoins)(tx, input.typeArguments[1], input.raiseHedgeCoins, input.raiseHedgeAmount, config.sponsored);
     var mainBalance = tx.moveCall({
         target: "0x2::coin::into_balance",
         typeArguments: [input.typeArguments[0]],

package/dist/src/typus-launch/funding-vault/authority-entry.js

@@ -1,20 +1,4 @@
 "use strict";
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.newVault = newVault;
 exports.updateRegistrySetting = updateRegistrySetting;
@@ -26,6 +10,7 @@ exports.depositToDeepbookBalanceManager = depositToDeepbookBalanceManager;
 exports.withdrawFromDeepbookBalanceManager = withdrawFromDeepbookBalanceManager;
 exports.increaseFund = increaseFund;
 exports.decreaseFund = decreaseFund;
+var utils_1 = require("../../../src/utils");
 /**
     entry fun new_vault<TOKEN>(
         version: &Version,
@@ -159,16 +144,7 @@ function withdrawFundFromDeepbookBalanceManager(config, tx, input) {
     ) {
 */
 function depositToDeepbookBalanceManager(config, tx, input) {
-    var _a = __read(input.typeArguments[0] == "0x2::sui::SUI" ||
-        input.typeArguments[0] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI"
-        ? tx.splitCoins(tx.gas, [tx.pure.u64(input.amount)])
-        : (function () {
-            var coin = input.coins.pop();
-            if (input.coins.length > 0) {
-                tx.mergeCoins(tx.object(coin), input.coins.map(function (coin) { return tx.object(coin); }));
-            }
-            return tx.splitCoins(tx.object(coin), [tx.pure.u64(input.amount)]);
-        })(), 1), coin = _a[0];
+    var coin = (0, utils_1.splitCoins)(tx, input.typeArguments[0], input.coins, input.amount);
     tx.moveCall({
         target: "".concat(config.package.launch.fundingVault, "::funding_vault::deposit_to_deepbook_balance_manager"),
         typeArguments: input.typeArguments,
@@ -213,16 +189,7 @@ function withdrawFromDeepbookBalanceManager(config, tx, input) {
     ) {
 */
 function increaseFund(config, tx, input) {
-    var _a = __read(input.typeArguments[0] == "0x2::sui::SUI" ||
-        input.typeArguments[0] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI"
-        ? tx.splitCoins(tx.gas, [tx.pure.u64(input.amount)])
-        : (function () {
-            var coin = input.coins.pop();
-            if (input.coins.length > 0) {
-                tx.mergeCoins(tx.object(coin), input.coins.map(function (coin) { return tx.object(coin); }));
-            }
-            return tx.splitCoins(tx.object(coin), [tx.pure.u64(input.amount)]);
-        })(), 1), coin = _a[0];
+    var coin = (0, utils_1.splitCoins)(tx, input.typeArguments[0], input.coins, input.amount);
     tx.moveCall({
         target: "".concat(config.package.launch.fundingVault, "::funding_vault::increase_fund"),
         typeArguments: input.typeArguments,

package/dist/src/typus-launch/funding-vault/user-entry.js

@@ -1,24 +1,9 @@
 "use strict";
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.raiseFund = raiseFund;
 exports.reduceFund = reduceFund;
 var constants_1 = require("../../../src/constants");
+var utils_1 = require("../../../src/utils");
 /**
     public fun raise_fund<TOKEN>(
         version: &Version,
@@ -30,16 +15,7 @@ var constants_1 = require("../../../src/constants");
     ) {
 */
 function raiseFund(config, tx, input) {
-    var _a = __read(input.typeArguments[0] == "0x2::sui::SUI" ||
-        input.typeArguments[0] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI"
-        ? tx.splitCoins(tx.gas, [tx.pure.u64(input.amount)])
-        : (function () {
-            var coin = input.coins.pop();
-            if (input.coins.length > 0) {
-                tx.mergeCoins(tx.object(coin), input.coins.map(function (coin) { return tx.object(coin); }));
-            }
-            return tx.splitCoins(tx.object(coin), [tx.pure.u64(input.amount)]);
-        })(), 1), coin = _a[0];
+    var coin = (0, utils_1.splitCoins)(tx, input.typeArguments[0], input.coins, input.amount);
     tx.moveCall({
         target: "".concat(config.package.launch.fundingVault, "::funding_vault::raise_fund"),
         typeArguments: input.typeArguments,

package/dist/src/typus-safu/user-entry.js

@@ -23,7 +23,7 @@ var utils_1 = require("../../src/utils");
     ) {
  */
 function getRaiseFundTx(config, tx, input) {
-    var coin = (0, utils_1.splitCoins)(tx, input.typeArguments[0], input.raiseCoins, input.raiseAmount);
+    var coin = (0, utils_1.splitCoins)(tx, input.typeArguments[0], input.raiseCoins, input.raiseAmount, config.sponsored);
     var raiseBalance = tx.moveCall({
         target: "0x2::coin::into_balance",
         typeArguments: [input.typeArguments[0]],
@@ -79,7 +79,7 @@ function getReduceFundTx(config, tx, input) {
             tx.pure.u64(input.reduceFromWarmup),
             tx.pure.u64(input.reduceFromActive),
             tx.pure.u64(input.reduceFromInactive),
-            tx.object((0, utils_1.splitCoins)(tx, constants_1.tokenType.MAINNET.SUI, [], input.feeAmount)),
+            tx.object((0, utils_1.splitCoins)(tx, constants_1.tokenType.MAINNET.SUI, [], input.feeAmount, config.sponsored)),
             tx.object(constants_1.CLOCK),
         ],
     });

package/dist/src/utils/sponsoredTx.js

@@ -63,8 +63,11 @@ function getSponsoredTx(provider, sender, tx) {
                     response = _a.sent();
                     return [4 /*yield*/, response.json()];
                 case 3:
-                    sponsoredResponse = (_a.sent());
+                    sponsoredResponse = _a.sent();
                     // console.log(sponsoredResponse);
+                    if (sponsoredResponse.data) {
+                        console.error("getSponsoredTx error: ", sponsoredResponse.data.details);
+                    }
                     return [2 /*return*/, sponsoredResponse];
             }
         });

package/dist/src/utils/tools.d.ts

@@ -7,7 +7,7 @@ export declare function AddressFromBytes(x: any): string;
 export declare const insertAt: (str: string, sub: string, pos: number) => string;
 export declare const checkNumber: (str: any) => boolean;
 export declare const countFloating: (value: number | BigNumber) => number;
-export declare function splitCoins(tx: Transaction, token: string, coins: string[], amount: string): {
+export declare function splitCoins(tx: Transaction, token: string, coins: string[], amount: string, sponsored?: boolean): {
     $kind: "NestedResult";
     NestedResult: [number, number];
 };

package/dist/src/utils/tools.js

@@ -1,37 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __read = (this && this.__read) || function (o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
@@ -60,7 +27,7 @@ exports.promptYesNo = promptYesNo;
 exports.getNumberStringWithDecimal = getNumberStringWithDecimal;
 var utils_1 = require("@mysten/sui/utils");
 var constants_1 = require("../../src/constants");
-var readline = __importStar(require("readline"));
+// import * as readline from "readline";
 var bignumber_js_1 = __importDefault(require("bignumber.js"));
 var sleep = function (ms) { return new Promise(function (resolve) { return setTimeout(resolve, ms); }); };
 exports.sleep = sleep;
@@ -104,8 +71,9 @@ var countFloating = function (value) {
     return num.split(".")[1].length;
 };
 exports.countFloating = countFloating;
-function splitCoins(tx, token, coins, amount) {
+function splitCoins(tx, token, coins, amount, sponsored) {
     var _a, _b;
+    if (sponsored === void 0) { sponsored = false; }
     var coin;
     if (coins.length == 0) {
         // support zero coin input for closing position
@@ -116,7 +84,7 @@ function splitCoins(tx, token, coins, amount) {
         }), 1), coin = _a[0];
     }
     else {
-        _b = __read((0, utils_1.normalizeStructTag)(token) == constants_1.tokenType.MAINNET.SUI
+        _b = __read((0, utils_1.normalizeStructTag)(token) == constants_1.tokenType.MAINNET.SUI && !sponsored
             ? tx.splitCoins(tx.gas, [tx.pure.u64(amount)])
             : (function () {
                 var coin = coins.pop();
@@ -129,22 +97,22 @@ function splitCoins(tx, token, coins, amount) {
     return coin;
 }
 function promptYesNo(question) {
-    var rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    return new Promise(function (resolve) {
-        rl.question("".concat(question, " [y/N] "), function (answer) {
-            var normalizedAnswer = answer.toLowerCase();
-            if (normalizedAnswer === "y" || normalizedAnswer === "yes") {
-                resolve(true);
-            }
-            else {
-                resolve(false);
-            }
-            rl.close();
-        });
-    });
+    // const rl = readline.createInterface({
+    //     input: process.stdin,
+    //     output: process.stdout,
+    // });
+    // return new Promise((resolve) => {
+    //     rl.question(`${question} [y/N] `, (answer) => {
+    //         const normalizedAnswer = answer.toLowerCase();
+    //         if (normalizedAnswer === "y" || normalizedAnswer === "yes") {
+    //             resolve(true);
+    //         } else {
+    //             resolve(false);
+    //         }
+    //         rl.close();
+    //     });
+    // });
+    return new Promise(function (resolve) { return resolve(true); });
 }
 function getNumberStringWithDecimal(input, decimal) {
     input = input.padStart(decimal, "0");

package/dist/src/utils/typusConfig.d.ts

@@ -6,6 +6,7 @@ export declare class TypusConfig {
     version: Version;
     registry: Registry;
     object: Object;
+    sponsored: boolean;
     static parse(json: any): TypusConfig;
     static local(path: any): TypusConfig;
     static default(network: "MAINNET" | "TESTNET", customRpcEndpoint: string | null, branch?: string): Promise<TypusConfig>;

package/dist/src/utils/typusConfig.js

@@ -77,6 +77,7 @@ var camelcase_keys_deep_1 = __importDefault(require("camelcase-keys-deep"));
 var fs = __importStar(require("fs"));
 var TypusConfig = /** @class */ (function () {
     function TypusConfig() {
+        this.sponsored = false;
     }
     TypusConfig.parse = function (json) {
         return JSON.parse(JSON.stringify((0, camelcase_keys_deep_1.default)(json)));

package/package.json

@@ -2,7 +2,7 @@
     "name": "@typus/typus-sdk",
     "author": "Typus",
     "description": "typus sdk",
-    "version": "1.7.13",
+    "version": "1.7.14",
     "dependencies": {
         "@mysten/bcs": "1.6.1",
         "@mysten/kiosk": "0.12.6",