@typus/typus-sdk 1.7.12 → 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/api/price.js

@@ -150,7 +150,6 @@ function getPythLatestPrice() {
                         var price = p.price.price / Math.pow(10, -p.price.expo);
                         map.set(token, price);
                     });
-                    console.log(map);
                     return [2 /*return*/, map];
                 case 3: return [2 /*return*/];
             }
@@ -288,8 +287,8 @@ var pythId = {
     "04cfeb7b143eb9c48e9b074125c1a3447b85f59c31164dc20c1beaa6f21f2b6b": "BLUE",
     "5fc11ffe4975b624be495be038da30e30bee2004d8ae6282b5364577ef4ca92c": "BLUB",
     "765d2ba906dbc32ca17cc11f5310a89e9ee1f6420508c63861f2f8ba4ee34bb2": "XAU",
-    "eba0732395fae9dec4bae12e52760b35fc1c5671e2da8b449c9af4efe5d54341": "WAL",
+    eba0732395fae9dec4bae12e52760b35fc1c5671e2da8b449c9af4efe5d54341: "WAL",
     "4279e31cc369bbcc2faf022b382b080e32a8e689ff20fbc530d2a603eb6cd98b": "HYPE",
-    "ec5d399846a9209f3fe5881d70aae9268c94339ff9817e8d18ff19fa05eea1c8": "XRP",
+    ec5d399846a9209f3fe5881d70aae9268c94339ff9817e8d18ff19fa05eea1c8: "XRP",
 };
 // getPythLatestPrice();

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

@@ -0,0 +1,8 @@
+import { Transaction } from "@mysten/sui/transactions";
+import { SuiClient } from "@mysten/sui/client";
+export declare function getSponsoredTx(provider: SuiClient, sender: string, tx: Transaction): Promise<sponsoredResponse>;
+interface sponsoredResponse {
+    txBytes: string;
+    sponsorSig: string;
+}
+export {};

package/dist/src/utils/sponsoredTx.js

@@ -0,0 +1,75 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSponsoredTx = getSponsoredTx;
+var sui_1 = require("@shinami/clients/sui");
+function getSponsoredTx(provider, sender, tx) {
+    return __awaiter(this, void 0, void 0, function () {
+        var gaslessTx, body, apiUrl, headers, response, sponsoredResponse;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, sui_1.buildGaslessTransaction)(tx, {
+                        sui: provider,
+                        sender: sender,
+                    })];
+                case 1:
+                    gaslessTx = _a.sent();
+                    body = JSON.stringify(gaslessTx);
+                    apiUrl = "https://sponsored-gas-752051381467.asia-southeast1.run.app";
+                    headers = {
+                        "Content-Type": "application/json",
+                    };
+                    return [4 /*yield*/, fetch(apiUrl, {
+                            method: "POST",
+                            headers: headers,
+                            body: body,
+                        })];
+                case 2:
+                    response = _a.sent();
+                    return [4 /*yield*/, response.json()];
+                case 3:
+                    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

@@ -1,5 +1,5 @@
-import BigNumber from "bignumber.js";
 import { Transaction } from "@mysten/sui/transactions";
+import BigNumber from "bignumber.js";
 export declare const sleep: (ms: number) => Promise<unknown>;
 export declare const prettify_big_number: (value: any, decimal: any) => string;
 export declare function U64FromBytes(x: any): bigint;
@@ -7,7 +7,9 @@ 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];
 };
+export declare function promptYesNo(question: string): Promise<boolean>;
+export declare function getNumberStringWithDecimal(input: string, decimal: number): string;

package/dist/src/utils/tools.js

@@ -23,9 +23,12 @@ exports.countFloating = exports.checkNumber = exports.insertAt = exports.prettif
 exports.U64FromBytes = U64FromBytes;
 exports.AddressFromBytes = AddressFromBytes;
 exports.splitCoins = splitCoins;
-var bignumber_js_1 = __importDefault(require("bignumber.js"));
-var constants_1 = require("../../src/constants");
+exports.promptYesNo = promptYesNo;
+exports.getNumberStringWithDecimal = getNumberStringWithDecimal;
 var utils_1 = require("@mysten/sui/utils");
+var constants_1 = require("../../src/constants");
+// 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;
 var prettify_big_number = function (value, decimal) {
@@ -68,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
@@ -80,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();
@@ -92,3 +96,27 @@ function splitCoins(tx, token, coins, amount) {
     }
     return coin;
 }
+function promptYesNo(question) {
+    // 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");
+    var integer = input.slice(0, input.length - decimal).replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+    var float = input.slice(input.length - decimal, input.length);
+    return "".concat(integer == "" ? "0" : integer, ".").concat(float);
+}

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,12 +2,13 @@
     "name": "@typus/typus-sdk",
     "author": "Typus",
     "description": "typus sdk",
-    "version": "1.7.12",
+    "version": "1.7.14",
     "dependencies": {
         "@mysten/bcs": "1.6.1",
         "@mysten/kiosk": "0.12.6",
         "@mysten/sui": "1.30.0",
         "@pythnetwork/pyth-sui-js": "^2.1.0",
+        "@shinami/clients": "^0.9.6",
         "@typemove/sui": "^1.6.1",
         "@types/node": "^20.5.7",
         "bignumber.js": "^9.1.2",