@typus/typus-sdk 1.4.19 → 1.4.21

package/dist/src/auto-bid/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./user-entry";
 export * from "./view-function";
+export * from "./token-user-entry";

package/dist/src/auto-bid/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./user-entry"), exports);
 __exportStar(require("./view-function"), exports);
+__exportStar(require("./token-user-entry"), exports);

package/dist/src/auto-bid/token-user-entry.d.ts

@@ -1,9 +1,47 @@
 import { TransactionBlock } from "@mysten/sui.js/transactions";
-export declare function getMfudNewStrategyTx(gasBudget: number, packageId: string, typeArguments: string[], // D_TOKEN, B_TOKEN
-registry: string, strategy_pool: string, vault_index: string, signal_index: string, coins: string[], mfudPackageId: string, mfudRegistry: string, mfudAmount: string, size: string, price_percentage: string, max_times: string, target_rounds: string[]): TransactionBlock;
-export declare function getMfudUpdateStrategyTx(gasBudget: number, packageId: string, typeArguments: string[], // D_TOKEN, B_TOKEN
-registry: string, strategy_pool: string, vault_index: string, signal_index: string, strategy_index: string, coins: string[], mfudPackageId: string, mfudRegistry: string, mfudAmount: string, size: string | null, price_percentage: string | null, max_times: string | null, target_rounds: string[]): TransactionBlock;
-export declare function getMfudCloseStrategyTx(gasBudget: number, packageId: string, typeArguments: string[], // D_TOKEN, B_TOKEN
-registry: string, strategy_pool: string, vault_index: string, signal_index: string, strategy_index: string, mfudPackageId: string, mfudRegistry: string, sender: string): TransactionBlock;
-export declare function getMfudWithdrawProfitStrategyTx(gasBudget: number, packageId: string, typeArguments: string[], // D_TOKEN, B_TOKEN
-registry: string, strategy_pool: string, vault_index: string, signal_index: string, strategy_index: string, mfudPackageId: string, mfudRegistry: string, sender: string, txBlock?: TransactionBlock): TransactionBlock;
+import { TypusConfig } from "src/utils";
+export declare function getTokenNewStrategyTx(config: TypusConfig, tx: TransactionBlock, input: {
+    typeArguments: string[];
+    typusTokenType: string;
+    strategy_pool: string;
+    vault_index: string;
+    signal_index: string;
+    coins: string[];
+    amount: string;
+    size: string;
+    price_percentage: string;
+    max_times: string;
+    target_rounds: string[];
+}): TransactionBlock;
+export declare function getTokenUpdateStrategyTx(config: TypusConfig, tx: TransactionBlock, input: {
+    typeArguments: string[];
+    typusTokenType: string;
+    strategy_pool: string;
+    vault_index: string;
+    signal_index: string;
+    strategy_index: string;
+    coins: string[];
+    amount: string;
+    size: string | null;
+    price_percentage: string | null;
+    max_times: string | null;
+    target_rounds: string[];
+}): TransactionBlock;
+export declare function getTokenCloseStrategyTx(config: TypusConfig, tx: TransactionBlock, input: {
+    typeArguments: string[];
+    typusTokenType: string;
+    strategy_pool: string;
+    vault_index: string;
+    signal_index: string;
+    strategy_index: string;
+    user: string;
+}): TransactionBlock;
+export declare function getTokenWithdrawProfitStrategyTx(config: TypusConfig, tx: TransactionBlock, input: {
+    typeArguments: string[];
+    typusTokenType: string;
+    strategy_pool: string;
+    vault_index: string;
+    signal_index: string;
+    strategy_index: string;
+    user: string;
+}): TransactionBlock;

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

@@ -16,111 +16,154 @@ var __read = (this && this.__read) || function (o, n) {
     return ar;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMfudNewStrategyTx = getMfudNewStrategyTx;
-exports.getMfudUpdateStrategyTx = getMfudUpdateStrategyTx;
-exports.getMfudCloseStrategyTx = getMfudCloseStrategyTx;
-exports.getMfudWithdrawProfitStrategyTx = getMfudWithdrawProfitStrategyTx;
-var transactions_1 = require("@mysten/sui.js/transactions");
-function getMfudNewStrategyTx(gasBudget, packageId, typeArguments, // D_TOKEN, B_TOKEN
-registry, strategy_pool, vault_index, signal_index, coins, mfudPackageId, mfudRegistry, mfudAmount, size, price_percentage, max_times, target_rounds) {
-    var tx = new transactions_1.TransactionBlock();
-    var input_coin = tx.moveCall({
-        target: "".concat(mfudPackageId, "::mfud::mint"),
-        arguments: [tx.object(mfudRegistry), tx.makeMoveVec({ objects: coins.map(function (id) { return tx.object(id); }) }), tx.pure(mfudAmount)],
+exports.getTokenNewStrategyTx = getTokenNewStrategyTx;
+exports.getTokenUpdateStrategyTx = getTokenUpdateStrategyTx;
+exports.getTokenCloseStrategyTx = getTokenCloseStrategyTx;
+exports.getTokenWithdrawProfitStrategyTx = getTokenWithdrawProfitStrategyTx;
+function getTokenNewStrategyTx(config, tx, input) {
+    var typusTokenRegistry = "";
+    switch (input.typusTokenType.split("::")[1]) {
+        case "mfud":
+            typusTokenRegistry = config.registry.token.mfud;
+            break;
+        default:
+            console.log("No such token exists!");
+            break;
+    }
+    var tToken = tx.moveCall({
+        target: "".concat(config.package.token, "::").concat(input.typusTokenType.split("::")[1], "::mint"),
+        arguments: [
+            tx.object(typusTokenRegistry),
+            tx.makeMoveVec({ objects: input.coins.map(function (id) { return tx.object(id); }) }),
+            tx.pure(input.amount),
+        ],
     });
     tx.moveCall({
-        target: "".concat(packageId, "::auto_bid::new_strategy"),
-        typeArguments: typeArguments,
+        target: "".concat(config.package.dovSingle, "::auto_bid::new_strategy"),
+        typeArguments: input.typeArguments,
         arguments: [
-            tx.object(registry),
-            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.object(config.registry.dov.dovSingle),
+            tx.object(input.strategy_pool),
+            tx.pure(input.vault_index),
+            tx.pure(input.signal_index),
+            tx.pure(input.size),
+            tx.pure(input.price_percentage),
+            tx.pure(input.max_times),
+            tx.pure(input.target_rounds),
+            tToken,
         ],
     });
-    tx.setGasBudget(gasBudget);
     return tx;
 }
-function getMfudUpdateStrategyTx(gasBudget, packageId, typeArguments, // D_TOKEN, B_TOKEN
-registry, strategy_pool, vault_index, signal_index, strategy_index, coins, mfudPackageId, mfudRegistry, mfudAmount, size, price_percentage, max_times, target_rounds) {
-    var tx = new transactions_1.TransactionBlock();
+function getTokenUpdateStrategyTx(config, tx, input) {
+    var typusTokenRegistry = "";
+    switch (input.typusTokenType.split("::")[1]) {
+        case "mfud":
+            typusTokenRegistry = config.registry.token.mfud;
+            break;
+        default:
+            console.log("No such token exists!");
+            break;
+    }
     var _a = __read(tx.moveCall({
-        target: "".concat(mfudPackageId, "::mfud::mint"),
-        arguments: [tx.object(mfudRegistry), tx.makeMoveVec({ objects: coins.map(function (id) { return tx.object(id); }) }), tx.pure(mfudAmount)],
-    }), 1), input_coin = _a[0];
+        target: "".concat(config.package.token, "::").concat(input.typusTokenType.split("::")[1], "::mint"),
+        arguments: [
+            tx.object(typusTokenRegistry),
+            tx.makeMoveVec({ objects: input.coins.map(function (id) { return tx.object(id); }) }),
+            tx.pure(input.amount),
+        ],
+    }), 1), tToken = _a[0];
     tx.moveCall({
-        target: "".concat(packageId, "::auto_bid::update_strategy"),
-        typeArguments: typeArguments,
+        target: "".concat(config.package.dovSingle, "::auto_bid::update_strategy"),
+        typeArguments: input.typeArguments,
         arguments: [
-            tx.object(registry),
-            tx.object(strategy_pool),
-            tx.pure(vault_index),
-            tx.pure(signal_index),
-            tx.pure(strategy_index),
-            tx.pure(size ? [size] : []),
-            tx.pure(price_percentage ? [price_percentage] : []),
-            tx.pure(max_times ? [max_times] : []),
-            tx.pure(target_rounds),
-            tx.makeMoveVec({ objects: [input_coin] }),
+            tx.object(config.registry.dov.dovSingle),
+            tx.object(input.strategy_pool),
+            tx.pure(input.vault_index),
+            tx.pure(input.signal_index),
+            tx.pure(input.strategy_index),
+            tx.pure(input.size ? [input.size] : []),
+            tx.pure(input.price_percentage ? [input.price_percentage] : []),
+            tx.pure(input.max_times ? [input.max_times] : []),
+            tx.pure(input.target_rounds),
+            tx.makeMoveVec({ objects: [tToken] }),
         ],
     });
-    tx.setGasBudget(gasBudget);
     return tx;
 }
-function getMfudCloseStrategyTx(gasBudget, packageId, typeArguments, // D_TOKEN, B_TOKEN
-registry, strategy_pool, vault_index, signal_index, strategy_index, mfudPackageId, mfudRegistry, sender) {
-    var tx = new transactions_1.TransactionBlock();
+function getTokenCloseStrategyTx(config, tx, input) {
+    var typusTokenRegistry = "";
+    switch (input.typusTokenType.split("::")[1]) {
+        case "mfud":
+            typusTokenRegistry = config.registry.token.mfud;
+            break;
+        default:
+            console.log("No such token exists!");
+            break;
+    }
     var _a = __read(tx.moveCall({
-        target: "".concat(packageId, "::auto_bid::close_strategy"),
-        typeArguments: typeArguments,
-        arguments: [tx.object(registry), tx.object(strategy_pool), tx.pure(vault_index), tx.pure(signal_index), tx.pure(strategy_index)],
+        target: "".concat(config.package.dovSingle, "::auto_bid::close_strategy"),
+        typeArguments: input.typeArguments,
+        arguments: [
+            tx.object(config.registry.dov.dovSingle),
+            tx.object(input.strategy_pool),
+            tx.pure(input.vault_index),
+            tx.pure(input.signal_index),
+            tx.pure(input.strategy_index),
+        ],
     }), 2), d_token = _a[0], b_token = _a[1];
-    if (typeArguments[0].endsWith("MFUD")) {
-        var fud_coin = tx.moveCall({
-            target: "".concat(mfudPackageId, "::mfud::burn"),
-            arguments: [tx.object(mfudRegistry), d_token],
+    if (input.typeArguments[0] == input.typusTokenType) {
+        var token = tx.moveCall({
+            target: "".concat(config.package.token, "::").concat(input.typusTokenType.split("::")[1], "::burn"),
+            arguments: [tx.object(typusTokenRegistry), d_token],
         });
-        tx.transferObjects([tx.object(fud_coin)], sender);
+        tx.transferObjects([tx.object(token)], input.user);
     }
     else {
-        tx.transferObjects([d_token], sender);
+        tx.transferObjects([d_token], input.user);
     }
-    if (typeArguments[1].endsWith("MFUD")) {
-        var fud_coin = tx.moveCall({
-            target: "".concat(mfudPackageId, "::mfud::burn"),
-            arguments: [tx.object(mfudRegistry), b_token],
+    if (input.typeArguments[1] == input.typusTokenType) {
+        var token = tx.moveCall({
+            target: "".concat(config.package.token, "::").concat(input.typusTokenType.split("::")[1], "::burn"),
+            arguments: [tx.object(typusTokenRegistry), b_token],
         });
-        tx.transferObjects([tx.object(fud_coin)], sender);
+        tx.transferObjects([tx.object(token)], input.user);
     }
     else {
-        tx.transferObjects([b_token], sender);
+        tx.transferObjects([b_token], input.user);
     }
-    tx.setGasBudget(gasBudget);
     return tx;
 }
-function getMfudWithdrawProfitStrategyTx(gasBudget, packageId, typeArguments, // D_TOKEN, B_TOKEN
-registry, strategy_pool, vault_index, signal_index, strategy_index, mfudPackageId, mfudRegistry, sender, txBlock) {
-    var tx = txBlock ? txBlock : new transactions_1.TransactionBlock();
+function getTokenWithdrawProfitStrategyTx(config, tx, input) {
+    var typusTokenRegistry = "";
+    switch (input.typusTokenType.split("::")[1]) {
+        case "mfud":
+            typusTokenRegistry = config.registry.token.mfud;
+            break;
+        default:
+            console.log("No such token exists!");
+            break;
+    }
     var d_token = tx.moveCall({
-        target: "".concat(packageId, "::auto_bid::withdraw_profit"),
-        typeArguments: typeArguments,
-        arguments: [tx.object(registry), tx.object(strategy_pool), tx.pure(vault_index), tx.pure(signal_index), tx.pure(strategy_index)],
+        target: "".concat(config.package.dovSingle, "::auto_bid::withdraw_profit"),
+        typeArguments: input.typeArguments,
+        arguments: [
+            tx.object(config.registry.dov.dovSingle),
+            tx.object(input.strategy_pool),
+            tx.pure(input.vault_index),
+            tx.pure(input.signal_index),
+            tx.pure(input.strategy_index),
+        ],
     });
-    if (typeArguments[0].endsWith("MFUD")) {
-        var fud_coin = tx.moveCall({
-            target: "".concat(mfudPackageId, "::mfud::burn"),
-            arguments: [tx.object(mfudRegistry), d_token],
+    if (input.typeArguments[0] == input.typusTokenType) {
+        var token = tx.moveCall({
+            target: "".concat(config.package.token, "::").concat(input.typusTokenType.split("::")[1], "::burn"),
+            arguments: [tx.object(typusTokenRegistry), d_token],
         });
-        tx.transferObjects([tx.object(fud_coin)], sender);
+        tx.transferObjects([tx.object(token)], input.user);
     }
     else {
-        tx.transferObjects([d_token], sender);
+        tx.transferObjects([d_token], input.user);
     }
-    tx.setGasBudget(gasBudget);
     return tx;
 }

package/dist/src/auto-bid/user-entry.d.ts

@@ -1,4 +1,5 @@
 import { TransactionBlock } from "@mysten/sui.js/transactions";
+import { TypusConfig } from "src/utils";
 /**
     entry fun new_strategy<B_TOKEN>(
         strategy_pool: &mut StrategyPool,
@@ -12,8 +13,18 @@ import { TransactionBlock } from "@mysten/sui.js/transactions";
         ctx: &mut TxContext
     )
 */
-export declare function getNewStrategyTx(gasBudget: number, packageId: string, typeArguments: string[], // D_TOKEN, B_TOKEN
-registry: string, strategy_pool: string, vault_index: string, signal_index: string, coins: string[], amount: string, size: string, price_percentage: string, max_times: string, target_rounds: string[]): TransactionBlock;
+export declare function getNewStrategyTx(config: TypusConfig, tx: TransactionBlock, input: {
+    typeArguments: string[];
+    strategy_pool: string;
+    vault_index: string;
+    signal_index: string;
+    coins: string[];
+    amount: string;
+    size: string;
+    price_percentage: string;
+    max_times: string;
+    target_rounds: string[];
+}): TransactionBlock;
 /**
     entry fun close_strategy<D_TOKEN, B_TOKEN>(
         strategy_pool: &mut StrategyPoolV2,
@@ -23,10 +34,22 @@ registry: string, strategy_pool: string, vault_index: string, signal_index: stri
         ctx: &mut TxContext
     )
 */
-export declare function getCloseStrategyTx(gasBudget: number, packageId: string, typeArguments: string[], // D_TOKEN, B_TOKEN
-registry: string, strategy_pool: string, vault_index: string, signal_index: string, strategy_index: string, sender: string, txBlock?: TransactionBlock): TransactionBlock;
-export declare function getWithdrawProfitStrategyTx(gasBudget: number, packageId: string, typeArguments: string[], // D_TOKEN, B_TOKEN
-registry: string, strategy_pool: string, vault_index: string, signal_index: string, strategy_index: string, sender: string, txBlock?: TransactionBlock): TransactionBlock;
+export declare function getCloseStrategyTx(config: TypusConfig, tx: TransactionBlock, input: {
+    typeArguments: string[];
+    strategy_pool: string;
+    vault_index: string;
+    signal_index: string;
+    strategy_index: string;
+    user: string;
+}): TransactionBlock;
+export declare function getWithdrawProfitStrategyTx(config: TypusConfig, tx: TransactionBlock, input: {
+    typeArguments: string[];
+    strategy_pool: string;
+    vault_index: string;
+    signal_index: string;
+    strategy_index: string;
+    user: string;
+}): TransactionBlock;
 /**
     entry fun update_strategy<D_TOKEN, B_TOKEN>(
         strategy_pool: &mut StrategyPoolV2,
@@ -41,5 +64,16 @@ registry: string, strategy_pool: string, vault_index: string, signal_index: stri
         ctx: & TxContext
     )
 */
-export declare function getUpdateStrategyTx(gasBudget: number, packageId: string, typeArguments: string[], // D_TOKEN, B_TOKEN
-registry: string, strategy_pool: string, vault_index: string, signal_index: string, strategy_index: string, coins: string[], amount: string, size: string | null, price_percentage: string | null, max_times: string | null, target_rounds: string[]): TransactionBlock;
+export declare function getUpdateStrategyTx(config: TypusConfig, tx: TransactionBlock, input: {
+    typeArguments: string[];
+    strategy_pool: string;
+    vault_index: string;
+    signal_index: string;
+    strategy_index: string;
+    coins: string[];
+    amount: string;
+    size: string | null;
+    price_percentage: string | null;
+    max_times: string | null;
+    target_rounds: string[];
+}): TransactionBlock;

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

@@ -20,7 +20,6 @@ exports.getNewStrategyTx = getNewStrategyTx;
 exports.getCloseStrategyTx = getCloseStrategyTx;
 exports.getWithdrawProfitStrategyTx = getWithdrawProfitStrategyTx;
 exports.getUpdateStrategyTx = getUpdateStrategyTx;
-var transactions_1 = require("@mysten/sui.js/transactions");
 /**
     entry fun new_strategy<B_TOKEN>(
         strategy_pool: &mut StrategyPool,
@@ -34,53 +33,50 @@ var transactions_1 = require("@mysten/sui.js/transactions");
         ctx: &mut TxContext
     )
 */
-function getNewStrategyTx(gasBudget, packageId, typeArguments, // D_TOKEN, B_TOKEN
-registry, strategy_pool, vault_index, signal_index, coins, amount, size, price_percentage, max_times, target_rounds) {
-    var tx = new transactions_1.TransactionBlock();
+function getNewStrategyTx(config, tx, input) {
     if (
     // B_TOKEN
-    typeArguments[1] == "0x2::sui::SUI" ||
-        typeArguments[1] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI") {
-        var _a = __read(tx.splitCoins(tx.gas, [tx.pure(amount)]), 1), input_coin = _a[0];
+    input.typeArguments[1] == "0x2::sui::SUI" ||
+        input.typeArguments[1] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI") {
+        var _a = __read(tx.splitCoins(tx.gas, [tx.pure(input.amount)]), 1), input_coin = _a[0];
         tx.moveCall({
-            target: "".concat(packageId, "::auto_bid::new_strategy"),
-            typeArguments: typeArguments,
+            target: "".concat(config.package.dovSingle, "::auto_bid::new_strategy"),
+            typeArguments: input.typeArguments,
             arguments: [
-                tx.object(registry),
-                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),
+                tx.object(config.registry.dov.dovSingle),
+                tx.object(input.strategy_pool),
+                tx.pure(input.vault_index),
+                tx.pure(input.signal_index),
+                tx.pure(input.size),
+                tx.pure(input.price_percentage),
+                tx.pure(input.max_times),
+                tx.pure(input.target_rounds),
                 input_coin,
             ],
         });
     }
     else {
-        var coin = coins.pop();
-        if (coins.length > 0) {
-            tx.mergeCoins(tx.object(coin), coins.map(function (coin) { return tx.object(coin); }));
+        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(amount)]), 1), input_coin = _b[0];
+        var _b = __read(tx.splitCoins(tx.object(coin), [tx.pure(input.amount)]), 1), input_coin = _b[0];
         tx.moveCall({
-            target: "".concat(packageId, "::auto_bid::new_strategy"),
-            typeArguments: typeArguments,
+            target: "".concat(config.package.dovSingle, "::auto_bid::new_strategy"),
+            typeArguments: input.typeArguments,
             arguments: [
-                tx.object(registry),
-                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),
+                tx.object(config.registry.dov.dovSingle),
+                tx.object(input.strategy_pool),
+                tx.pure(input.vault_index),
+                tx.pure(input.signal_index),
+                tx.pure(input.size),
+                tx.pure(input.price_percentage),
+                tx.pure(input.max_times),
+                tx.pure(input.target_rounds),
                 input_coin,
             ],
         });
     }
-    tx.setGasBudget(gasBudget);
     return tx;
 }
 /**
@@ -92,28 +88,34 @@ registry, strategy_pool, vault_index, signal_index, coins, amount, size, price_p
         ctx: &mut TxContext
     )
 */
-function getCloseStrategyTx(gasBudget, packageId, typeArguments, // D_TOKEN, B_TOKEN
-registry, strategy_pool, vault_index, signal_index, strategy_index, sender, txBlock) {
-    var tx = txBlock ? txBlock : new transactions_1.TransactionBlock();
+function getCloseStrategyTx(config, tx, input) {
     var _a = __read(tx.moveCall({
-        target: "".concat(packageId, "::auto_bid::close_strategy"),
-        typeArguments: typeArguments,
-        arguments: [tx.object(registry), tx.object(strategy_pool), tx.pure(vault_index), tx.pure(signal_index), tx.pure(strategy_index)],
+        target: "".concat(config.package.dovSingle, "::auto_bid::close_strategy"),
+        typeArguments: input.typeArguments,
+        arguments: [
+            tx.object(config.registry.dov.dovSingle),
+            tx.object(input.strategy_pool),
+            tx.pure(input.vault_index),
+            tx.pure(input.signal_index),
+            tx.pure(input.strategy_index),
+        ],
     }), 2), d_token = _a[0], b_token = _a[1];
-    tx.transferObjects([d_token, b_token], sender);
-    tx.setGasBudget(gasBudget);
+    tx.transferObjects([d_token, b_token], input.user);
     return tx;
 }
-function getWithdrawProfitStrategyTx(gasBudget, packageId, typeArguments, // D_TOKEN, B_TOKEN
-registry, strategy_pool, vault_index, signal_index, strategy_index, sender, txBlock) {
-    var tx = txBlock ? txBlock : new transactions_1.TransactionBlock();
+function getWithdrawProfitStrategyTx(config, tx, input) {
     var d_token = tx.moveCall({
-        target: "".concat(packageId, "::auto_bid::withdraw_profit"),
-        typeArguments: typeArguments,
-        arguments: [tx.object(registry), tx.object(strategy_pool), tx.pure(vault_index), tx.pure(signal_index), tx.pure(strategy_index)],
+        target: "".concat(config.package.dovSingle, "::auto_bid::withdraw_profit"),
+        typeArguments: input.typeArguments,
+        arguments: [
+            tx.object(config.registry.dov.dovSingle),
+            tx.object(input.strategy_pool),
+            tx.pure(input.vault_index),
+            tx.pure(input.signal_index),
+            tx.pure(input.strategy_index),
+        ],
     });
-    tx.transferObjects([d_token], sender);
-    tx.setGasBudget(gasBudget);
+    tx.transferObjects([d_token], input.user);
     return tx;
 }
 /**
@@ -130,74 +132,71 @@ registry, strategy_pool, vault_index, signal_index, strategy_index, sender, txBl
         ctx: & TxContext
     )
 */
-function getUpdateStrategyTx(gasBudget, packageId, typeArguments, // D_TOKEN, B_TOKEN
-registry, strategy_pool, vault_index, signal_index, strategy_index, coins, amount, size, price_percentage, max_times, target_rounds) {
-    var tx = new transactions_1.TransactionBlock();
+function getUpdateStrategyTx(config, tx, input) {
     if (
     // B_TOKEN
-    typeArguments[1] == "0x2::sui::SUI" ||
-        typeArguments[1] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI") {
-        if (amount) {
-            var _a = __read(tx.splitCoins(tx.gas, [tx.pure(amount)]), 1), input_coin = _a[0];
+    input.typeArguments[1] == "0x2::sui::SUI" ||
+        input.typeArguments[1] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI") {
+        if (input.amount) {
+            var _a = __read(tx.splitCoins(tx.gas, [tx.pure(input.amount)]), 1), input_coin = _a[0];
             tx.moveCall({
-                target: "".concat(packageId, "::auto_bid::update_strategy"),
-                typeArguments: typeArguments,
+                target: "".concat(config.package.dovSingle, "::auto_bid::update_strategy"),
+                typeArguments: input.typeArguments,
                 arguments: [
-                    tx.object(registry),
-                    tx.object(strategy_pool),
-                    tx.pure(vault_index),
-                    tx.pure(signal_index),
-                    tx.pure(strategy_index),
-                    tx.pure(size ? [size] : []),
-                    tx.pure(price_percentage ? [price_percentage] : []),
-                    tx.pure(max_times ? [max_times] : []),
-                    tx.pure(target_rounds),
+                    tx.object(config.registry.dov.dovSingle),
+                    tx.object(input.strategy_pool),
+                    tx.pure(input.vault_index),
+                    tx.pure(input.signal_index),
+                    tx.pure(input.strategy_index),
+                    tx.pure(input.size ? [input.size] : []),
+                    tx.pure(input.price_percentage ? [input.price_percentage] : []),
+                    tx.pure(input.max_times ? [input.max_times] : []),
+                    tx.pure(input.target_rounds),
                     tx.makeMoveVec({ objects: [input_coin] }),
                 ],
             });
         }
         else {
             tx.moveCall({
-                target: "".concat(packageId, "::auto_bid::update_strategy"),
-                typeArguments: typeArguments,
+                target: "".concat(config.package.dovSingle, "::auto_bid::update_strategy"),
+                typeArguments: input.typeArguments,
                 arguments: [
-                    tx.object(registry),
-                    tx.object(strategy_pool),
-                    tx.pure(vault_index),
-                    tx.pure(signal_index),
-                    tx.pure(strategy_index),
-                    tx.pure(size ? [size] : []),
-                    tx.pure(price_percentage ? [price_percentage] : []),
-                    tx.pure(max_times ? [max_times] : []),
-                    tx.pure(target_rounds),
+                    tx.object(config.registry.dov.dovSingle),
+                    tx.object(input.strategy_pool),
+                    tx.pure(input.vault_index),
+                    tx.pure(input.signal_index),
+                    tx.pure(input.strategy_index),
+                    tx.pure(input.size ? [input.size] : []),
+                    tx.pure(input.price_percentage ? [input.price_percentage] : []),
+                    tx.pure(input.max_times ? [input.max_times] : []),
+                    tx.pure(input.target_rounds),
                     tx.makeMoveVec({ objects: [] }),
                 ],
             });
         }
     }
     else {
-        var coin = coins.pop();
-        if (coins.length > 0) {
-            tx.mergeCoins(tx.object(coin), coins.map(function (coin) { return tx.object(coin); }));
+        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(amount)]), 1), input_coin = _b[0];
+        var _b = __read(tx.splitCoins(tx.object(coin), [tx.pure(input.amount)]), 1), input_coin = _b[0];
         tx.moveCall({
-            target: "".concat(packageId, "::auto_bid::update_strategy"),
-            typeArguments: typeArguments,
+            target: "".concat(config.package.dovSingle, "::auto_bid::update_strategy"),
+            typeArguments: input.typeArguments,
             arguments: [
-                tx.object(registry),
-                tx.object(strategy_pool),
-                tx.pure(vault_index),
-                tx.pure(signal_index),
-                tx.pure(strategy_index),
-                tx.pure(size ? [size] : []),
-                tx.pure(price_percentage ? [price_percentage] : []),
-                tx.pure(max_times ? [max_times] : []),
-                tx.pure(target_rounds),
+                tx.object(config.registry.dov.dovSingle),
+                tx.object(input.strategy_pool),
+                tx.pure(input.vault_index),
+                tx.pure(input.signal_index),
+                tx.pure(input.strategy_index),
+                tx.pure(input.size ? [input.size] : []),
+                tx.pure(input.price_percentage ? [input.price_percentage] : []),
+                tx.pure(input.max_times ? [input.max_times] : []),
+                tx.pure(input.target_rounds),
                 tx.makeMoveVec({ objects: [input_coin] }),
             ],
         });
     }
-    tx.setGasBudget(gasBudget);
     return tx;
 }