@typus/typus-sdk 1.4.84-ts → 1.4.85

package/dist/src/_framework/util.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTypeName = parseTypeName;
+exports.isTransactionArgument = isTransactionArgument;
+exports.isTransactionObjectArgument = isTransactionObjectArgument;
+exports.obj = obj;
+exports.pure = pure;
+exports.option = option;
+exports.generic = generic;
+exports.vector = vector;
+exports.typeArgIsPure = typeArgIsPure;
+exports.compressSuiAddress = compressSuiAddress;
+exports.compressSuiType = compressSuiType;
+exports.composeSuiType = composeSuiType;
+var bcs_1 = require("@mysten/sui.js/bcs");
+function parseTypeName(name) {
+    var parsed = bcs_1.bcs.parseTypeName(name);
+    return { typeName: parsed.name, typeArgs: parsed.params };
+}
+function isTransactionArgument(arg) {
+    if (!arg || typeof arg !== "object" || Array.isArray(arg)) {
+        return false;
+    }
+    return "kind" in arg;
+}
+function isTransactionObjectArgument(arg) {
+    if (!isTransactionArgument(arg)) {
+        return false;
+    }
+    if (arg.kind === "Input" && arg.type === "pure") {
+        return false;
+    }
+    return true;
+}
+function obj(txb, arg) {
+    return isTransactionArgument(arg) ? arg : txb.object(arg);
+}
+function pure(txb, arg, type) {
+    if (isTransactionArgument(arg)) {
+        return obj(txb, arg);
+    }
+    function getBcsForType(type) {
+        var _a = parseTypeName(type), typeName = _a.typeName, typeArgs = _a.typeArgs;
+        switch (typeName) {
+            case "bool":
+                return bcs_1.bcs.Bool;
+            case "u8":
+                return bcs_1.bcs.U8;
+            case "u16":
+                return bcs_1.bcs.U16;
+            case "u32":
+                return bcs_1.bcs.U32;
+            case "u64":
+                return bcs_1.bcs.U64;
+            case "u128":
+                return bcs_1.bcs.U128;
+            case "u256":
+                return bcs_1.bcs.U256;
+            case "address":
+                return bcs_1.bcs.Address;
+            case "0x1::string::String":
+            case "0x1::ascii::String":
+                return bcs_1.bcs.String;
+            case "0x2::object::ID":
+                return bcs_1.bcs.Address;
+            case "0x1::option::Option":
+                return bcs_1.bcs.option(getBcsForType(typeArgs[0]));
+            case "vector":
+                return bcs_1.bcs.vector(getBcsForType(typeArgs[0]));
+            default:
+                throw new Error("invalid primitive type ".concat(type));
+        }
+    }
+    function isOrHasNestedTransactionArgument(arg) {
+        if (Array.isArray(arg)) {
+            return arg.some(function (item) { return isOrHasNestedTransactionArgument(item); });
+        }
+        return isTransactionArgument(arg);
+    }
+    // handle some cases when TransactionArgument is nested within a vector or option
+    var _a = parseTypeName(type), typeName = _a.typeName, typeArgs = _a.typeArgs;
+    switch (typeName) {
+        case "0x1::option::Option":
+            if (arg === null) {
+                return txb.pure(bcs_1.bcs.option(bcs_1.bcs.Bool).serialize(null)); // bcs.Bool is arbitrary
+            }
+            if (isOrHasNestedTransactionArgument(arg)) {
+                throw new Error("nesting TransactionArgument is not supported");
+            }
+            break;
+        case "vector":
+            if (!Array.isArray(arg)) {
+                throw new Error("expected an array for vector type");
+            }
+            if (arg.length === 0) {
+                return txb.pure(bcs_1.bcs.vector(bcs_1.bcs.Bool).serialize([])); // bcs.Bool is arbitrary
+            }
+            if (arg.some(function (arg) { return Array.isArray(arg) && isOrHasNestedTransactionArgument(arg); })) {
+                throw new Error("nesting TransactionArgument is not supported");
+            }
+            if (isTransactionArgument(arg[0]) && arg.filter(function (arg) { return !isTransactionArgument(arg); }).length > 0) {
+                throw new Error("mixing TransactionArgument with other types is not supported");
+            }
+            if (isTransactionObjectArgument(arg[0])) {
+                return txb.makeMoveVec({
+                    objects: arg,
+                    type: typeArgs[0],
+                });
+            }
+    }
+    return txb.pure(getBcsForType(type).serialize(arg));
+}
+function option(txb, type, arg) {
+    if (isTransactionArgument(arg)) {
+        return arg;
+    }
+    if (typeArgIsPure(type)) {
+        return pure(txb, arg, "0x1::option::Option<".concat(type, ">"));
+    }
+    if (arg === null) {
+        return txb.moveCall({
+            target: "0x1::option::none",
+            typeArguments: [type],
+            arguments: [],
+        });
+    }
+    // wrap it with some
+    var val = generic(txb, type, arg);
+    return txb.moveCall({
+        target: "0x1::option::some",
+        typeArguments: [type],
+        arguments: [val],
+    });
+}
+function generic(txb, type, arg) {
+    if (typeArgIsPure(type)) {
+        return pure(txb, arg, type);
+    }
+    else {
+        var _a = parseTypeName(type), typeName = _a.typeName, typeArgs = _a.typeArgs;
+        if (typeName === "vector" && Array.isArray(arg)) {
+            var itemType = typeArgs[0];
+            return txb.makeMoveVec({
+                objects: arg.map(function (item) { return obj(txb, item); }),
+                type: itemType,
+            });
+        }
+        else {
+            return obj(txb, arg);
+        }
+    }
+}
+function vector(txb, itemType, items) {
+    if (typeArgIsPure(itemType)) {
+        return pure(txb, items, "vector<".concat(itemType, ">"));
+    }
+    else if (isTransactionArgument(items)) {
+        return items;
+    }
+    else {
+        var _a = parseTypeName(itemType), itemTypeName = _a.typeName, itemTypeArgs_1 = _a.typeArgs;
+        if (itemTypeName === "0x1::option::Option") {
+            var objects = items.map(function (item) { return option(txb, itemTypeArgs_1[0], item); });
+            return txb.makeMoveVec({
+                objects: objects,
+                type: itemType,
+            });
+        }
+        return txb.makeMoveVec({
+            objects: items,
+            type: itemType,
+        });
+    }
+}
+function typeArgIsPure(type) {
+    var _a = parseTypeName(type), typeName = _a.typeName, typeArgs = _a.typeArgs;
+    switch (typeName) {
+        case "bool":
+        case "u8":
+        case "u16":
+        case "u32":
+        case "u64":
+        case "u128":
+        case "u256":
+        case "address":
+        case "signer":
+            return true;
+        case "vector":
+            return typeArgIsPure(typeArgs[0]);
+        case "0x1::string::String":
+        case "0x1::ascii::String":
+        case "0x2::object::ID":
+            return true;
+        case "0x1::option::Option":
+            return typeArgIsPure(typeArgs[0]);
+        default:
+            return false;
+    }
+}
+function compressSuiAddress(addr) {
+    // remove leading zeros
+    var stripped = addr.split("0x").join("");
+    for (var i = 0; i < stripped.length; i++) {
+        if (stripped[i] !== "0") {
+            return "0x".concat(stripped.substring(i));
+        }
+    }
+    return "0x0";
+}
+// Recursively removes leading zeros from a type.
+// e.g. `0x00000002::module::Name<0x00001::a::C>` -> `0x2::module::Name<0x1::a::C>`
+function compressSuiType(type) {
+    var _a = parseTypeName(type), typeName = _a.typeName, typeArgs = _a.typeArgs;
+    switch (typeName) {
+        case "bool":
+        case "u8":
+        case "u16":
+        case "u32":
+        case "u64":
+        case "u128":
+        case "u256":
+        case "address":
+        case "signer":
+            return typeName;
+        case "vector":
+            return "vector<".concat(compressSuiType(typeArgs[0]), ">");
+        default: {
+            var tok = typeName.split("::");
+            tok[0] = compressSuiAddress(tok[0]);
+            var compressedName = tok.join("::");
+            if (typeArgs.length > 0) {
+                return "".concat(compressedName, "<").concat(typeArgs.map(function (typeArg) { return compressSuiType(typeArg); }).join(","), ">");
+            }
+            else {
+                return compressedName;
+            }
+        }
+    }
+}
+function composeSuiType(typeName) {
+    var typeArgs = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        typeArgs[_i - 1] = arguments[_i];
+    }
+    if (typeArgs.length > 0) {
+        return "".concat(typeName, "<").concat(typeArgs.join(", "), ">");
+    }
+    else {
+        return typeName;
+    }
+}

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

@@ -1,6 +1,6 @@
-import { Transaction } from "@mysten/sui/transactions";
+import { TransactionBlock } from "@mysten/sui.js/transactions";
 import { TypusConfig } from "../../src/utils";
-export declare function getTokenNewStrategyTx(config: TypusConfig, tx: Transaction, input: {
+export declare function getTokenNewStrategyTx(config: TypusConfig, tx: TransactionBlock, input: {
     typeArguments: string[];
     typusTokenType: string;
     vaultIndex: string;
@@ -11,8 +11,8 @@ export declare function getTokenNewStrategyTx(config: TypusConfig, tx: Transacti
     pricePercentage: string;
     maxTimes: string;
     targetRounds: string[];
-}): Transaction;
-export declare function getTokenUpdateStrategyTx(config: TypusConfig, tx: Transaction, input: {
+}): TransactionBlock;
+export declare function getTokenUpdateStrategyTx(config: TypusConfig, tx: TransactionBlock, input: {
     typeArguments: string[];
     typusTokenType: string;
     vaultIndex: string;
@@ -24,20 +24,20 @@ export declare function getTokenUpdateStrategyTx(config: TypusConfig, tx: Transa
     pricePercentage: string | null;
     maxTimes: string | null;
     targetRounds: string[];
-}): Transaction;
-export declare function getTokenCloseStrategyTx(config: TypusConfig, tx: Transaction, input: {
+}): TransactionBlock;
+export declare function getTokenCloseStrategyTx(config: TypusConfig, tx: TransactionBlock, input: {
     typeArguments: string[];
     typusTokenType: string;
     vaultIndex: string;
     signalIndex: string;
     strategyIndex: string;
     user: string;
-}): Transaction;
-export declare function getTokenWithdrawProfitStrategyTx(config: TypusConfig, tx: Transaction, input: {
+}): TransactionBlock;
+export declare function getTokenWithdrawProfitStrategyTx(config: TypusConfig, tx: TransactionBlock, input: {
     typeArguments: string[];
     typusTokenType: string;
     vaultIndex: string;
     signalIndex: string;
     strategyIndex: string;
     user: string;
-}): Transaction;
+}): TransactionBlock;

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

@@ -40,8 +40,8 @@ function getTokenNewStrategyTx(config, tx, input) {
         target: "".concat(input.typusTokenType.split("::")[0], "::").concat(input.typusTokenType.split("::")[1], "::mint"),
         arguments: [
             tx.object(typusTokenRegistry),
-            tx.makeMoveVec({ elements: input.coins.map(function (id) { return tx.object(id); }) }),
-            tx.pure.u64(input.amount),
+            tx.makeMoveVec({ objects: input.coins.map(function (id) { return tx.object(id); }) }),
+            tx.pure(input.amount),
         ],
     });
     tx.moveCall({
@@ -50,12 +50,12 @@ function getTokenNewStrategyTx(config, tx, input) {
         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),
+            tx.pure(input.vaultIndex),
+            tx.pure(input.signalIndex),
+            tx.pure(input.size),
+            tx.pure(input.pricePercentage),
+            tx.pure(input.maxTimes),
+            tx.pure(input.targetRounds),
             tToken,
         ],
     });
@@ -81,8 +81,8 @@ function getTokenUpdateStrategyTx(config, tx, input) {
         target: "".concat(input.typusTokenType.split("::")[0], "::").concat(input.typusTokenType.split("::")[1], "::mint"),
         arguments: [
             tx.object(typusTokenRegistry),
-            tx.makeMoveVec({ elements: input.coins.map(function (id) { return tx.object(id); }) }),
-            tx.pure.u64(input.amount),
+            tx.makeMoveVec({ objects: input.coins.map(function (id) { return tx.object(id); }) }),
+            tx.pure(input.amount),
         ],
     }), 1), tToken = _a[0];
     tx.moveCall({
@@ -91,14 +91,14 @@ function getTokenUpdateStrategyTx(config, tx, input) {
         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: [tToken] }),
+            tx.pure(input.vaultIndex),
+            tx.pure(input.signalIndex),
+            tx.pure(input.strategyIndex),
+            tx.pure(input.size ? [input.size] : []),
+            tx.pure(input.pricePercentage ? [input.pricePercentage] : []),
+            tx.pure(input.maxTimes ? [input.maxTimes] : []),
+            tx.pure(input.targetRounds),
+            tx.makeMoveVec({ objects: [tToken] }),
         ],
     });
     return tx;
@@ -125,9 +125,9 @@ function getTokenCloseStrategyTx(config, tx, input) {
         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(input.vaultIndex),
+            tx.pure(input.signalIndex),
+            tx.pure(input.strategyIndex),
         ],
     }), 2), d_token = _a[0], b_token = _a[1];
     if (input.typeArguments[0] == input.typusTokenType) {
@@ -174,9 +174,9 @@ function getTokenWithdrawProfitStrategyTx(config, tx, input) {
         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(input.vaultIndex),
+            tx.pure(input.signalIndex),
+            tx.pure(input.strategyIndex),
         ],
     });
     if (input.typeArguments[0] == input.typusTokenType) {

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

@@ -1,4 +1,4 @@
-import { Transaction } from "@mysten/sui/transactions";
+import { TransactionBlock } from "@mysten/sui.js/transactions";
 import { TypusConfig } from "../../src/utils";
 /**
     entry fun new_strategy<B_TOKEN>(
@@ -13,7 +13,7 @@ import { TypusConfig } from "../../src/utils";
         ctx: &mut TxContext
     )
 */
-export declare function getNewStrategyTx(config: TypusConfig, tx: Transaction, input: {
+export declare function getNewStrategyTx(config: TypusConfig, tx: TransactionBlock, input: {
     typeArguments: string[];
     vaultIndex: string;
     signalIndex: string;
@@ -23,7 +23,7 @@ export declare function getNewStrategyTx(config: TypusConfig, tx: Transaction, i
     pricePercentage: string;
     maxTimes: string;
     targetRounds: string[];
-}): Transaction;
+}): TransactionBlock;
 /**
     entry fun close_strategy<D_TOKEN, B_TOKEN>(
         strategy_pool: &mut StrategyPoolV2,
@@ -33,20 +33,20 @@ export declare function getNewStrategyTx(config: TypusConfig, tx: Transaction, i
         ctx: &mut TxContext
     )
 */
-export declare function getCloseStrategyTx(config: TypusConfig, tx: Transaction, input: {
+export declare function getCloseStrategyTx(config: TypusConfig, tx: TransactionBlock, input: {
     typeArguments: string[];
     vaultIndex: string;
     signalIndex: string;
     strategyIndex: string;
     user: string;
-}): Transaction;
-export declare function getWithdrawProfitStrategyTx(config: TypusConfig, tx: Transaction, input: {
+}): TransactionBlock;
+export declare function getWithdrawProfitStrategyTx(config: TypusConfig, tx: TransactionBlock, input: {
     typeArguments: string[];
     vaultIndex: string;
     signalIndex: string;
     strategyIndex: string;
     user: string;
-}): Transaction;
+}): TransactionBlock;
 /**
     entry fun update_strategy<D_TOKEN, B_TOKEN>(
         strategy_pool: &mut StrategyPoolV2,
@@ -61,7 +61,7 @@ export declare function getWithdrawProfitStrategyTx(config: TypusConfig, tx: Tra
         ctx: & TxContext
     )
 */
-export declare function getUpdateStrategyTx(config: TypusConfig, tx: Transaction, input: {
+export declare function getUpdateStrategyTx(config: TypusConfig, tx: TransactionBlock, input: {
     typeArguments: string[];
     vaultIndex: string;
     signalIndex: string;
@@ -72,4 +72,4 @@ export declare function getUpdateStrategyTx(config: TypusConfig, tx: Transaction
     pricePercentage: string | null;
     maxTimes: string | null;
     targetRounds: string[];
-}): Transaction;
+}): TransactionBlock;

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

@@ -38,19 +38,19 @@ function getNewStrategyTx(config, tx, input) {
     // 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];
+        var _a = __read(tx.splitCoins(tx.gas, [tx.pure(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),
+                tx.pure(input.vaultIndex),
+                tx.pure(input.signalIndex),
+                tx.pure(input.size),
+                tx.pure(input.pricePercentage),
+                tx.pure(input.maxTimes),
+                tx.pure(input.targetRounds),
                 input_coin,
             ],
         });
@@ -60,19 +60,19 @@ function getNewStrategyTx(config, tx, input) {
         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];
+        var _b = __read(tx.splitCoins(tx.object(coin), [tx.pure(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),
+                tx.pure(input.vaultIndex),
+                tx.pure(input.signalIndex),
+                tx.pure(input.size),
+                tx.pure(input.pricePercentage),
+                tx.pure(input.maxTimes),
+                tx.pure(input.targetRounds),
                 input_coin,
             ],
         });
@@ -95,9 +95,9 @@ function getCloseStrategyTx(config, tx, input) {
         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(input.vaultIndex),
+            tx.pure(input.signalIndex),
+            tx.pure(input.strategyIndex),
         ],
     }), 2), d_token = _a[0], b_token = _a[1];
     tx.transferObjects([d_token, b_token], input.user);
@@ -110,9 +110,9 @@ function getWithdrawProfitStrategyTx(config, tx, input) {
         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(input.vaultIndex),
+            tx.pure(input.signalIndex),
+            tx.pure(input.strategyIndex),
         ],
     });
     tx.transferObjects([d_token], input.user);
@@ -138,21 +138,21 @@ function getUpdateStrategyTx(config, tx, input) {
     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];
+            var _a = __read(tx.splitCoins(tx.gas, [tx.pure(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] }),
+                    tx.pure(input.vaultIndex),
+                    tx.pure(input.signalIndex),
+                    tx.pure(input.strategyIndex),
+                    tx.pure(input.size ? [input.size] : []),
+                    tx.pure(input.pricePercentage ? [input.pricePercentage] : []),
+                    tx.pure(input.maxTimes ? [input.maxTimes] : []),
+                    tx.pure(input.targetRounds),
+                    tx.makeMoveVec({ objects: [input_coin] }),
                 ],
             });
         }
@@ -163,14 +163,14 @@ function getUpdateStrategyTx(config, tx, input) {
                 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: [] }),
+                    tx.pure(input.vaultIndex),
+                    tx.pure(input.signalIndex),
+                    tx.pure(input.strategyIndex),
+                    tx.pure(input.size ? [input.size] : []),
+                    tx.pure(input.pricePercentage ? [input.pricePercentage] : []),
+                    tx.pure(input.maxTimes ? [input.maxTimes] : []),
+                    tx.pure(input.targetRounds),
+                    tx.makeMoveVec({ objects: [] }),
                 ],
             });
         }
@@ -180,21 +180,21 @@ function getUpdateStrategyTx(config, tx, input) {
         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];
+        var _b = __read(tx.splitCoins(tx.object(coin), [tx.pure(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] }),
+                tx.pure(input.vaultIndex),
+                tx.pure(input.signalIndex),
+                tx.pure(input.strategyIndex),
+                tx.pure(input.size ? [input.size] : []),
+                tx.pure(input.pricePercentage ? [input.pricePercentage] : []),
+                tx.pure(input.maxTimes ? [input.maxTimes] : []),
+                tx.pure(input.targetRounds),
+                tx.makeMoveVec({ objects: [input_coin] }),
             ],
         });
     }