@typus/typus-sdk 1.1.57 → 1.2.0

package/lib/utils/typus-dov-single-v2/user-entry.js

@@ -16,8 +16,7 @@ var __read = (this && this.__read) || function (o, n) {
     return ar;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNewStrategyTx = exports.getRebateTx = exports.getTransferBidReceiptTx = exports.getExerciseTx = exports.getNewBidTx = exports.getRedeemTx = exports.getHarvestTx = exports.getClaimTx = exports.getCompoundTx = exports.getUnsubscribeTx = exports.getWithdrawTx = exports.getDepositTx = void 0;
-var transactions_1 = require("@mysten/sui.js/transactions");
+exports.getRebateTx = exports.getTransferBidReceiptTx = exports.getExerciseTx = exports.getNewBidTx = exports.getWithdrawHarvestClaimTx = exports.getRedeemTx = exports.getHarvestTx = exports.getClaimTx = exports.getCompoundTx = exports.getUnsubscribeTx = exports.getWithdrawTx = exports.getDepositTx = void 0;
 var constants_1 = require("../../constants");
 /**
     public fun deposit<D_TOKEN, B_TOKEN>(
@@ -30,58 +29,57 @@ var constants_1 = require("../../constants");
         ctx: &mut TxContext,
     )
 */
-function getDepositTx(tx, typusFrameworkOriginPackageId, typusFrameworkPackageId, packageId, typeArguments, registry, index, coins, amount, receipts, user, usingSponsoredGasCoin) {
-    if (usingSponsoredGasCoin === void 0) { usingSponsoredGasCoin = false; }
-    if (!usingSponsoredGasCoin &&
-        (typeArguments[0] == "0x2::sui::SUI" ||
-            typeArguments[0] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI")) {
-        var _a = __read(tx.splitCoins(tx.gas, [tx.pure(amount)]), 1), coin = _a[0];
-        var result = tx.moveCall({
-            target: "".concat(packageId, "::tails_staking::deposit"),
-            typeArguments: typeArguments,
+function getDepositTx(input) {
+    if (!input.usingSponsoredGasCoin &&
+        (input.typeArguments[0] == "0x2::sui::SUI" ||
+            input.typeArguments[0] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI")) {
+        var _a = __read(input.tx.splitCoins(input.tx.gas, [input.tx.pure(input.amount)]), 1), coin = _a[0];
+        var result = input.tx.moveCall({
+            target: "".concat(input.typusDovSinglePackageId, "::tails_staking::deposit"),
+            typeArguments: input.typeArguments,
             arguments: [
-                tx.object(registry),
-                tx.pure(index),
-                tx.makeMoveVec({ objects: [coin] }),
-                tx.pure(amount),
-                tx.makeMoveVec({
-                    type: "".concat(typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
-                    objects: receipts.map(function (id) { return tx.object(id); }),
+                input.tx.object(input.typusDovSingleRegistry),
+                input.tx.pure(input.index),
+                input.tx.makeMoveVec({ objects: [coin] }),
+                input.tx.pure(input.amount),
+                input.tx.makeMoveVec({
+                    type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
+                    objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
                 }),
-                tx.pure(constants_1.CLOCK),
+                input.tx.pure(constants_1.CLOCK),
             ],
         });
-        tx.moveCall({
-            target: "".concat(typusFrameworkPackageId, "::utils::transfer_coins"),
-            typeArguments: [typeArguments[0]],
-            arguments: [tx.object(result[0]), tx.pure(user)],
+        input.tx.moveCall({
+            target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_coins"),
+            typeArguments: [input.typeArguments[0]],
+            arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
         });
-        tx.transferObjects([tx.object(result[1])], user);
+        input.tx.transferObjects([input.tx.object(result[1])], input.user);
     }
     else {
-        var result = tx.moveCall({
-            target: "".concat(packageId, "::tails_staking::deposit"),
-            typeArguments: typeArguments,
+        var result = input.tx.moveCall({
+            target: "".concat(input.typusDovSinglePackageId, "::tails_staking::deposit"),
+            typeArguments: input.typeArguments,
             arguments: [
-                tx.object(registry),
-                tx.pure(index),
-                tx.makeMoveVec({ objects: coins.map(function (id) { return tx.object(id); }) }),
-                tx.pure(amount),
-                tx.makeMoveVec({
-                    type: "".concat(typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
-                    objects: receipts.map(function (id) { return tx.object(id); }),
+                input.tx.object(input.typusDovSingleRegistry),
+                input.tx.pure(input.index),
+                input.tx.makeMoveVec({ objects: input.coins.map(function (coin) { return input.tx.object(coin); }) }),
+                input.tx.pure(input.amount),
+                input.tx.makeMoveVec({
+                    type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
+                    objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
                 }),
-                tx.pure(constants_1.CLOCK),
+                input.tx.pure(constants_1.CLOCK),
             ],
         });
-        tx.moveCall({
-            target: "".concat(typusFrameworkPackageId, "::utils::transfer_coins"),
-            typeArguments: [typeArguments[0]],
-            arguments: [tx.object(result[0]), tx.pure(user)],
+        input.tx.moveCall({
+            target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_coins"),
+            typeArguments: [input.typeArguments[0]],
+            arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
         });
-        tx.transferObjects([tx.object(result[1])], user);
+        input.tx.transferObjects([input.tx.object(result[1])], input.user);
     }
-    return tx;
+    return input.tx;
 }
 exports.getDepositTx = getDepositTx;
 /**
@@ -94,31 +92,31 @@ exports.getDepositTx = getDepositTx;
         ctx: &mut TxContext,
     )
 */
-function getWithdrawTx(tx, typusFrameworkOriginPackageId, typusFrameworkPackageId, packageId, typeArguments, registry, index, receipts, user, share) {
-    var result = tx.moveCall({
-        target: "".concat(packageId, "::tails_staking::withdraw"),
-        typeArguments: typeArguments,
+function getWithdrawTx(input) {
+    var result = input.tx.moveCall({
+        target: "".concat(input.typusDovSinglePackageId, "::tails_staking::withdraw"),
+        typeArguments: input.typeArguments,
         arguments: [
-            tx.object(registry),
-            tx.pure(index),
-            tx.makeMoveVec({
-                type: "".concat(typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
-                objects: receipts.map(function (id) { return tx.object(id); }),
+            input.tx.object(input.typusDovSingleRegistry),
+            input.tx.pure(input.index),
+            input.tx.makeMoveVec({
+                type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
+                objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
             }),
-            tx.pure(share ? [share] : []),
-            tx.pure(constants_1.CLOCK),
+            input.tx.pure(input.share ? [input.share] : []),
+            input.tx.pure(constants_1.CLOCK),
         ],
     });
-    tx.moveCall({
-        target: "".concat(typusFrameworkPackageId, "::utils::transfer_balance"),
-        typeArguments: [typeArguments[0]],
-        arguments: [tx.object(result[0]), tx.pure(user)],
+    input.tx.moveCall({
+        target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
+        typeArguments: [input.typeArguments[0]],
+        arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
     });
-    tx.moveCall({
-        target: "".concat(typusFrameworkPackageId, "::vault::transfer_deposit_receipt"),
-        arguments: [tx.object(result[1]), tx.pure(user)],
+    input.tx.moveCall({
+        target: "".concat(input.typusFrameworkPackageId, "::vault::transfer_deposit_receipt"),
+        arguments: [input.tx.object(result[1]), input.tx.pure(input.user)],
     });
-    return tx;
+    return input.tx;
 }
 exports.getWithdrawTx = getWithdrawTx;
 /**
@@ -131,23 +129,23 @@ exports.getWithdrawTx = getWithdrawTx;
         ctx: &mut TxContext,
     )
 */
-function getUnsubscribeTx(tx, typusFrameworkOriginPackageId, packageId, typeArguments, registry, index, receipts, user, share) {
-    var result = tx.moveCall({
-        target: "".concat(packageId, "::tails_staking::unsubscribe"),
-        typeArguments: typeArguments,
+function getUnsubscribeTx(input) {
+    var result = input.tx.moveCall({
+        target: "".concat(input.typusDovSinglePackageId, "::tails_staking::unsubscribe"),
+        typeArguments: input.typeArguments,
         arguments: [
-            tx.object(registry),
-            tx.pure(index),
-            tx.makeMoveVec({
-                type: "".concat(typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
-                objects: receipts.map(function (id) { return tx.object(id); }),
+            input.tx.object(input.typusDovSingleRegistry),
+            input.tx.pure(input.index),
+            input.tx.makeMoveVec({
+                type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
+                objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
             }),
-            tx.pure(share ? [share] : []),
-            tx.pure(constants_1.CLOCK),
+            input.tx.pure(input.share ? [input.share] : []),
+            input.tx.pure(constants_1.CLOCK),
         ],
     });
-    tx.transferObjects([tx.object(result[0])], user);
-    return tx;
+    input.tx.transferObjects([input.tx.object(result[0])], input.user);
+    return input.tx;
 }
 exports.getUnsubscribeTx = getUnsubscribeTx;
 /**
@@ -159,22 +157,38 @@ exports.getUnsubscribeTx = getUnsubscribeTx;
         ctx: &mut TxContext,
     )
 */
-function getCompoundTx(tx, typusFrameworkOriginPackageId, packageId, typeArguments, registry, index, receipts, user) {
-    var result = tx.moveCall({
-        target: "".concat(packageId, "::tails_staking::compound"),
-        typeArguments: typeArguments,
+function getCompoundTx(input) {
+    var result = input.tx.moveCall({
+        target: "".concat(input.typusDovSinglePackageId, "::tails_staking::compound"),
+        typeArguments: input.typeArguments,
         arguments: [
-            tx.object(registry),
-            tx.pure(index),
-            tx.makeMoveVec({
-                type: "".concat(typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
-                objects: receipts.map(function (id) { return tx.object(id); }),
+            input.tx.object(input.typusDovSingleRegistry),
+            input.tx.pure(input.index),
+            input.tx.makeMoveVec({
+                type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
+                objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
             }),
-            tx.object(constants_1.CLOCK),
+            input.tx.object(constants_1.CLOCK),
         ],
     });
-    tx.transferObjects([tx.object(result[0])], user);
-    return tx;
+    if (input.incentiveToken) {
+        input.typeArguments.push(input.incentiveToken);
+        input.tx = getRedeemTx({
+            tx: input.tx,
+            typusFrameworkOriginPackageId: input.typusFrameworkOriginPackageId,
+            typusFrameworkPackageId: input.typusFrameworkPackageId,
+            typusDovSinglePackageId: input.typusDovSinglePackageId,
+            typusDovSingleRegistry: input.typusDovSingleRegistry,
+            typeArguments: input.typeArguments,
+            index: input.index,
+            receipts: [input.tx.object(result[0])],
+            user: input.user,
+        });
+    }
+    else {
+        input.tx.transferObjects([input.tx.object(result[0])], input.user);
+    }
+    return input.tx;
 }
 exports.getCompoundTx = getCompoundTx;
 /**
@@ -185,29 +199,29 @@ exports.getCompoundTx = getCompoundTx;
         ctx: &mut TxContext,
     )
 */
-function getClaimTx(tx, typusFrameworkOriginPackageId, typusFrameworkPackageId, packageId, typeArguments, registry, index, receipts, user) {
-    var result = tx.moveCall({
-        target: "".concat(packageId, "::tds_user_entry::claim"),
-        typeArguments: typeArguments,
+function getClaimTx(input) {
+    var result = input.tx.moveCall({
+        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::claim"),
+        typeArguments: input.typeArguments,
         arguments: [
-            tx.object(registry),
-            tx.pure(index),
-            tx.makeMoveVec({
-                type: "".concat(typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
-                objects: receipts.map(function (id) { return tx.object(id); }),
+            input.tx.object(input.typusDovSingleRegistry),
+            input.tx.pure(input.index),
+            input.tx.makeMoveVec({
+                type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
+                objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
             }),
         ],
     });
-    tx.moveCall({
-        target: "".concat(typusFrameworkPackageId, "::utils::transfer_balance"),
-        typeArguments: [typeArguments[0]],
-        arguments: [tx.object(result[0]), tx.pure(user)],
+    input.tx.moveCall({
+        target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
+        typeArguments: [input.typeArguments[0]],
+        arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
     });
-    tx.moveCall({
-        target: "".concat(typusFrameworkPackageId, "::vault::transfer_deposit_receipt"),
-        arguments: [tx.object(result[1]), tx.pure(user)],
+    input.tx.moveCall({
+        target: "".concat(input.typusFrameworkPackageId, "::vault::transfer_deposit_receipt"),
+        arguments: [input.tx.object(result[1]), input.tx.pure(input.user)],
     });
-    return tx;
+    return input.tx;
 }
 exports.getClaimTx = getClaimTx;
 /**
@@ -218,29 +232,49 @@ exports.getClaimTx = getClaimTx;
         ctx: &mut TxContext,
     )
 */
-function getHarvestTx(tx, typusFrameworkOriginPackageId, typusFrameworkPackageId, packageId, typeArguments, registry, index, receipts, user) {
-    var result = tx.moveCall({
-        target: "".concat(packageId, "::tds_user_entry::harvest"),
-        typeArguments: typeArguments,
+function getHarvestTx(input) {
+    var result = input.tx.moveCall({
+        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::harvest"),
+        typeArguments: input.typeArguments,
         arguments: [
-            tx.object(registry),
-            tx.pure(index),
-            tx.makeMoveVec({
-                type: "".concat(typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
-                objects: receipts.map(function (id) { return tx.object(id); }),
+            input.tx.object(input.typusDovSingleRegistry),
+            input.tx.pure(input.index),
+            input.tx.makeMoveVec({
+                type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
+                objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
             }),
         ],
     });
-    tx.moveCall({
-        target: "".concat(typusFrameworkPackageId, "::utils::transfer_balance"),
-        typeArguments: [typeArguments[1]],
-        arguments: [tx.object(result[0]), tx.pure(user)],
-    });
-    tx.moveCall({
-        target: "".concat(typusFrameworkPackageId, "::vault::transfer_deposit_receipt"),
-        arguments: [tx.object(result[1]), tx.pure(user)],
+    input.tx.moveCall({
+        target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
+        typeArguments: [input.typeArguments[1]],
+        arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
     });
-    return tx;
+    if (input.incentiveToken) {
+        input.typeArguments.push(input.incentiveToken);
+        var receipt = input.tx.moveCall({
+            target: "0x1::option::destroy_some",
+            arguments: [input.tx.object(result[1])],
+        });
+        input.tx = getRedeemTx({
+            tx: input.tx,
+            typusFrameworkOriginPackageId: input.typusFrameworkOriginPackageId,
+            typusFrameworkPackageId: input.typusFrameworkPackageId,
+            typusDovSinglePackageId: input.typusDovSinglePackageId,
+            typusDovSingleRegistry: input.typusDovSingleRegistry,
+            typeArguments: input.typeArguments,
+            index: input.index,
+            receipts: [input.tx.object(receipt)],
+            user: input.user,
+        });
+    }
+    else {
+        input.tx.moveCall({
+            target: "".concat(input.typusFrameworkPackageId, "::vault::transfer_deposit_receipt"),
+            arguments: [input.tx.object(result[1]), input.tx.pure(input.user)],
+        });
+    }
+    return input.tx;
 }
 exports.getHarvestTx = getHarvestTx;
 /**
@@ -251,31 +285,128 @@ exports.getHarvestTx = getHarvestTx;
         ctx: &mut TxContext,
     )
 */
-function getRedeemTx(tx, typusFrameworkOriginPackageId, typusFrameworkPackageId, packageId, typeArguments, registry, index, receipts, user) {
-    var result = tx.moveCall({
-        target: "".concat(packageId, "::tds_user_entry::redeem"),
-        typeArguments: typeArguments,
+function getRedeemTx(input) {
+    var result = input.tx.moveCall({
+        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::redeem"),
+        typeArguments: input.typeArguments,
         arguments: [
-            tx.object(registry),
-            tx.pure(index),
-            tx.makeMoveVec({
-                type: "".concat(typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
-                objects: receipts.map(function (id) { return tx.object(id); }),
+            input.tx.object(input.typusDovSingleRegistry),
+            input.tx.pure(input.index),
+            input.tx.makeMoveVec({
+                type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
+                objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
             }),
         ],
     });
-    tx.moveCall({
-        target: "".concat(typusFrameworkPackageId, "::utils::transfer_balance"),
-        typeArguments: [typeArguments[2]],
-        arguments: [tx.object(result[0]), tx.pure(user)],
+    input.tx.moveCall({
+        target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
+        typeArguments: [input.typeArguments[2]],
+        arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
     });
-    tx.moveCall({
-        target: "".concat(typusFrameworkPackageId, "::vault::transfer_deposit_receipt"),
-        arguments: [tx.object(result[1]), tx.pure(user)],
+    input.tx.moveCall({
+        target: "".concat(input.typusFrameworkPackageId, "::vault::transfer_deposit_receipt"),
+        arguments: [input.tx.object(result[1]), input.tx.pure(input.user)],
     });
-    return tx;
+    return input.tx;
 }
 exports.getRedeemTx = getRedeemTx;
+function getWithdrawHarvestClaimTx(input) {
+    var result = input.withdraw
+        ? input.tx.moveCall({
+            target: "".concat(input.typusDovSinglePackageId, "::tails_staking::withdraw"),
+            typeArguments: input.typeArguments,
+            arguments: [
+                input.tx.object(input.typusDovSingleRegistry),
+                input.tx.pure(input.index),
+                input.tx.makeMoveVec({
+                    type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
+                    objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
+                }),
+                input.tx.pure([]),
+                input.tx.pure(constants_1.CLOCK),
+            ],
+        })
+        : undefined;
+    if (input.withdraw) {
+        input.tx.moveCall({
+            target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
+            typeArguments: [input.typeArguments[0]],
+            arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
+        });
+    }
+    result = input.harvest
+        ? input.tx.moveCall({
+            target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::harvest"),
+            typeArguments: input.typeArguments,
+            arguments: [
+                input.tx.object(input.typusDovSingleRegistry),
+                input.tx.pure(input.index),
+                input.tx.makeMoveVec({
+                    type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
+                    objects: result ? [result[1]] : input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
+                }),
+            ],
+        })
+        : result;
+    if (input.harvest) {
+        input.tx.moveCall({
+            target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
+            typeArguments: [input.typeArguments[1]],
+            arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
+        });
+    }
+    result = input.claim
+        ? input.tx.moveCall({
+            target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::claim"),
+            typeArguments: input.typeArguments,
+            arguments: [
+                input.tx.object(input.typusDovSingleRegistry),
+                input.tx.pure(input.index),
+                input.tx.makeMoveVec({
+                    type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
+                    objects: result ? [result[1]] : input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
+                }),
+            ],
+        })
+        : result;
+    if (input.claim) {
+        input.tx.moveCall({
+            target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
+            typeArguments: [input.typeArguments[0]],
+            arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
+        });
+    }
+    if (input.incentiveToken) {
+        input.typeArguments.push(input.incentiveToken);
+        var receipts = result
+            ? [
+                input.tx.object(input.tx.moveCall({
+                    target: "0x1::option::destroy_some",
+                    arguments: [input.tx.object(result[1])],
+                })),
+            ]
+            : input.receipts.map(function (receipt) { return input.tx.object(receipt); });
+        input.tx = getRedeemTx({
+            tx: input.tx,
+            typusFrameworkOriginPackageId: input.typusFrameworkOriginPackageId,
+            typusFrameworkPackageId: input.typusFrameworkPackageId,
+            typusDovSinglePackageId: input.typusDovSinglePackageId,
+            typusDovSingleRegistry: input.typusDovSingleRegistry,
+            typeArguments: input.typeArguments,
+            index: input.index,
+            receipts: receipts,
+            user: input.user,
+        });
+    }
+    else {
+        input.tx.moveCall({
+            target: "".concat(input.typusFrameworkPackageId, "::vault::transfer_deposit_receipt"),
+            arguments: [input.tx.object(result[1]), input.tx.pure(input.user)],
+        });
+    }
+    return input.tx;
+}
+exports.getWithdrawHarvestClaimTx = getWithdrawHarvestClaimTx;
 /**
     public(friend) entry fun new_bid<D_TOKEN, B_TOKEN>(
         registry: &mut Registry,
@@ -286,35 +417,39 @@ exports.getRedeemTx = getRedeemTx;
         ctx: &mut TxContext,
     )
 */
-function getNewBidTx(tx, packageId, typeArguments, registry, index, coins, size, premium_required, // fe float * b_token_decimal
-user, usingSponsoredGasCoin) {
-    if (usingSponsoredGasCoin === void 0) { usingSponsoredGasCoin = false; }
-    if (!usingSponsoredGasCoin &&
-        (typeArguments[1] == "0x2::sui::SUI" ||
-            typeArguments[1] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI")) {
-        var _a = __read(tx.splitCoins(tx.gas, [tx.pure(premium_required)]), 1), coin = _a[0];
-        var result = tx.moveCall({
-            target: "".concat(packageId, "::tails_staking::new_bid"),
-            typeArguments: typeArguments,
-            arguments: [tx.object(registry), tx.pure(index), tx.makeMoveVec({ objects: [coin] }), tx.pure(size), tx.pure("0x6")],
+function getNewBidTx(input) {
+    if (!input.usingSponsoredGasCoin &&
+        (input.typeArguments[1] == "0x2::sui::SUI" ||
+            input.typeArguments[1] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI")) {
+        var _a = __read(input.tx.splitCoins(input.tx.gas, [input.tx.pure(input.premium_required)]), 1), coin = _a[0];
+        var result = input.tx.moveCall({
+            target: "".concat(input.typusDovSinglePackageId, "::tails_staking::new_bid"),
+            typeArguments: input.typeArguments,
+            arguments: [
+                input.tx.object(input.typusDovSingleRegistry),
+                input.tx.pure(input.index),
+                input.tx.makeMoveVec({ objects: [coin] }),
+                input.tx.pure(input.size),
+                input.tx.pure("0x6"),
+            ],
         });
-        tx.transferObjects([tx.object(result[0])], user);
+        input.tx.transferObjects([input.tx.object(result[0])], input.user);
     }
     else {
-        var result = tx.moveCall({
-            target: "".concat(packageId, "::tails_staking::new_bid"),
-            typeArguments: typeArguments,
+        var result = input.tx.moveCall({
+            target: "".concat(input.typusDovSinglePackageId, "::tails_staking::new_bid"),
+            typeArguments: input.typeArguments,
             arguments: [
-                tx.object(registry),
-                tx.pure(index),
-                tx.makeMoveVec({ objects: coins.map(function (id) { return tx.object(id); }) }),
-                tx.pure(size),
-                tx.pure("0x6"),
+                input.tx.object(input.typusDovSingleRegistry),
+                input.tx.pure(input.index),
+                input.tx.makeMoveVec({ objects: input.coins.map(function (coin) { return input.tx.object(coin); }) }),
+                input.tx.pure(input.size),
+                input.tx.pure("0x6"),
             ],
         });
-        tx.transferObjects([tx.object(result[0])], user);
+        input.tx.transferObjects([input.tx.object(result[0])], input.user);
     }
-    return tx;
+    return input.tx;
 }
 exports.getNewBidTx = getNewBidTx;
 /**
@@ -325,25 +460,25 @@ exports.getNewBidTx = getNewBidTx;
         ctx: &mut TxContext,
     )
 */
-function getExerciseTx(tx, typusFrameworkOriginPackageId, typusFrameworkPackageId, packageId, typeArguments, registry, index, receipts, user) {
-    var result = tx.moveCall({
-        target: "".concat(packageId, "::tds_user_entry::exercise"),
-        typeArguments: typeArguments,
+function getExerciseTx(input) {
+    var result = input.tx.moveCall({
+        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::exercise"),
+        typeArguments: input.typeArguments,
         arguments: [
-            tx.object(registry),
-            tx.pure(index),
-            tx.makeMoveVec({
-                type: "".concat(typusFrameworkOriginPackageId, "::vault::TypusBidReceipt"),
-                objects: receipts.map(function (id) { return tx.object(id); }),
+            input.tx.object(input.typusDovSingleRegistry),
+            input.tx.pure(input.index),
+            input.tx.makeMoveVec({
+                type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusBidReceipt"),
+                objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
             }),
         ],
     });
-    tx.moveCall({
-        target: "".concat(typusFrameworkPackageId, "::utils::transfer_balance"),
-        typeArguments: [typeArguments[0]],
-        arguments: [tx.object(result[0]), tx.pure(user)],
+    input.tx.moveCall({
+        target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
+        typeArguments: [input.typeArguments[0]],
+        arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
     });
-    return tx;
+    return input.tx;
 }
 exports.getExerciseTx = getExerciseTx;
 /**
@@ -357,23 +492,21 @@ exports.getExerciseTx = getExerciseTx;
     ) {
 */
 function getTransferBidReceiptTx(input) {
-    var tx = new transactions_1.TransactionBlock();
-    tx.moveCall({
-        target: "".concat(input.packageId, "::tds_user_entry::transfer_bid_receipt"),
+    input.tx.moveCall({
+        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::transfer_bid_receipt"),
         typeArguments: input.typeArguments,
         arguments: [
-            tx.object(input.registry),
-            tx.pure(input.index),
-            tx.makeMoveVec({
+            input.tx.object(input.typusDovSingleRegistry),
+            input.tx.pure(input.index),
+            input.tx.makeMoveVec({
                 type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusBidReceipt"),
-                objects: input.receipts.map(function (id) { return tx.object(id); }),
+                objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
             }),
-            tx.pure(input.share ? [input.share] : []),
-            tx.pure(input.recipient),
+            input.tx.pure(input.share ? [input.share] : []),
+            input.tx.pure(input.recipient),
         ],
     });
-    tx.setGasBudget(input.gasBudget);
-    return tx;
+    return input.tx;
 }
 exports.getTransferBidReceiptTx = getTransferBidReceiptTx;
 /**
@@ -382,75 +515,22 @@ exports.getTransferBidReceiptTx = getTransferBidReceiptTx;
         ctx: &mut TxContext,
     )
 */
-function getRebateTx(gasBudget, packageId, typeArguments, registry) {
-    var tx = new transactions_1.TransactionBlock();
-    typeArguments.forEach(function (typeArgument) {
-        tx.moveCall({
-            target: "".concat(packageId, "::tds_user_entry::rebate"),
-            typeArguments: [typeArgument],
-            arguments: [tx.object(registry)],
-        });
+function getRebateTx(input) {
+    var result = input.tx.moveCall({
+        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::rebate"),
+        typeArguments: [input.typeArgument],
+        arguments: [input.tx.object(input.typusDovSingleRegistry)],
+    });
+    var balance = input.tx.moveCall({
+        target: "0x1::option::destroy_some",
+        typeArguments: ["0x2::balance::Balance<" + input.typeArgument + ">"],
+        arguments: [input.tx.object(result[0])],
+    });
+    input.tx.moveCall({
+        target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
+        typeArguments: [input.typeArgument],
+        arguments: [input.tx.object(balance), input.tx.pure(input.user)],
     });
-    tx.setGasBudget(gasBudget);
-    return tx;
+    return input.tx;
 }
 exports.getRebateTx = getRebateTx;
-/**
-    entry fun new_strategy<B_TOKEN>(
-        strategy_pool: &mut StrategyPool,
-        vault_index: u64,
-        signal_index: u64,
-        size: u64,
-        price_percentage: u64,
-        max_times: u64,
-        target_rounds: vector<u64>,
-        coin: Coin<B_TOKEN>,
-        ctx: &mut TxContext
-    )
-*/
-function getNewStrategyTx(gasBudget, packageId, typeArguments, // B_TOKEN
-strategy_pool, vault_index, signal_index, coins, amount, size, price_percentage, max_times, target_rounds) {
-    var tx = new transactions_1.TransactionBlock();
-    if (typeArguments[0] == "0x2::sui::SUI" ||
-        typeArguments[0] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI") {
-        var _a = __read(tx.splitCoins(tx.gas, [tx.pure(amount)]), 1), input_coin = _a[0];
-        tx.moveCall({
-            target: "".concat(packageId, "::auto_bid::new_strategy"),
-            typeArguments: typeArguments,
-            arguments: [
-                tx.object(strategy_pool),
-                tx.pure(vault_index),
-                tx.pure(signal_index),
-                tx.pure(size),
-                tx.pure(price_percentage),
-                tx.pure(max_times),
-                tx.pure(target_rounds),
-                input_coin,
-            ],
-        });
-    }
-    else {
-        var coin = coins.pop();
-        if (coins.length > 0) {
-            tx.mergeCoins(tx.object(coin), coins.map(function (id) { return tx.object(id); }));
-        }
-        var _b = __read(tx.splitCoins(tx.object(coin), [tx.pure(amount)]), 1), input_coin = _b[0];
-        tx.moveCall({
-            target: "".concat(packageId, "::auto_bid::new_strategy"),
-            typeArguments: typeArguments,
-            arguments: [
-                tx.object(strategy_pool),
-                tx.pure(vault_index),
-                tx.pure(signal_index),
-                tx.pure(size),
-                tx.pure(price_percentage),
-                tx.pure(max_times),
-                tx.pure(target_rounds),
-                input_coin,
-            ],
-        });
-    }
-    tx.setGasBudget(gasBudget);
-    return tx;
-}
-exports.getNewStrategyTx = getNewStrategyTx;