@typus/typus-sdk 1.4.84-ts → 1.4.85

package/dist/src/typus-dov-single-v2/token-user-entry.d.ts

@@ -1,6 +1,6 @@
-import { Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
+import { TransactionBlock, TransactionObjectArgument } from "@mysten/sui.js/transactions";
 import { TypusConfig } from "../../src/utils";
-export declare function getTokenRaiseFundTx(config: TypusConfig, tx: Transaction, input: {
+export declare function getTokenRaiseFundTx(config: TypusConfig, tx: TransactionBlock, input: {
     typeArguments: string[];
     typusTokenType: string;
     index: string;
@@ -10,8 +10,8 @@ export declare function getTokenRaiseFundTx(config: TypusConfig, tx: Transaction
     raiseFromPremium: boolean;
     raiseFromInactive: boolean;
     user: string;
-}): Transaction;
-export declare function getTokenReduceFundTx(config: TypusConfig, tx: Transaction, input: {
+}): TransactionBlock;
+export declare function getTokenReduceFundTx(config: TypusConfig, tx: TransactionBlock, input: {
     typeArguments: string[];
     typusTokenType: string;
     index: string;
@@ -22,8 +22,8 @@ export declare function getTokenReduceFundTx(config: TypusConfig, tx: Transactio
     reduceFromInactive: boolean;
     reduceFromIncentive: boolean;
     user: string;
-}): Transaction;
-export declare function getTokenNewBidTx(config: TypusConfig, tx: Transaction, input: {
+}): TransactionBlock;
+export declare function getTokenNewBidTx(config: TypusConfig, tx: TransactionBlock, input: {
     typeArguments: string[];
     typusTokenType: string;
     index: string;
@@ -31,23 +31,23 @@ export declare function getTokenNewBidTx(config: TypusConfig, tx: Transaction, i
     size: string;
     premium_required: string;
     user: string;
-}): Transaction;
-export declare function getTokenExerciseTx(config: TypusConfig, tx: Transaction, input: {
+}): TransactionBlock;
+export declare function getTokenExerciseTx(config: TypusConfig, tx: TransactionBlock, input: {
     typeArguments: string[];
     typusTokenType: string;
     index: string;
     receipts: string[] | TransactionObjectArgument[];
     user: string;
-}): Transaction;
-export declare function getTokenRebateTx(config: TypusConfig, tx: Transaction, input: {
+}): TransactionBlock;
+export declare function getTokenRebateTx(config: TypusConfig, tx: TransactionBlock, input: {
     typeArgument: string;
     typusTokenType: string;
     user: string;
-}): Transaction;
-export declare function getTokenCompoundWithRedeemTx(config: TypusConfig, tx: Transaction, input: {
+}): TransactionBlock;
+export declare function getTokenCompoundWithRedeemTx(config: TypusConfig, tx: TransactionBlock, input: {
     typeArguments: string[];
     typusTokenType: string;
     index: string;
     receipts: string[] | TransactionObjectArgument[];
     user: string;
-}): Transaction;
+}): TransactionBlock;

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

@@ -32,8 +32,8 @@ function getTokenRaiseFundTx(config, tx, input) {
                     target: "".concat(input.typusTokenType.split("::")[0], "::").concat(input.typusTokenType.split("::")[1], "::mint"),
                     arguments: [
                         tx.object(typusTokenRegistry),
-                        tx.makeMoveVec({ elements: input.raiseCoins }),
-                        tx.pure.u64(input.raiseAmount),
+                        tx.makeMoveVec({ objects: input.raiseCoins }),
+                        tx.pure(input.raiseAmount),
                     ],
                 })),
             ],
@@ -51,14 +51,14 @@ function getTokenRaiseFundTx(config, tx, input) {
             tx.object(config.registry.typus.user),
             tx.object(config.registry.typus.leaderboard),
             tx.object(config.registry.dov.dovSingle),
-            tx.pure.u64(input.index),
+            tx.pure(input.index),
             tx.makeMoveVec({
                 type: "".concat(config.packageOrigin.framework, "::vault::TypusDepositReceipt"),
-                elements: input.receipts.map(function (receipt) { return tx.object(receipt); }),
+                objects: input.receipts.map(function (receipt) { return tx.object(receipt); }),
             }),
             tx.object(typusTokenBalance),
-            tx.pure.bool(input.raiseFromPremium),
-            tx.pure.bool(input.raiseFromInactive),
+            tx.pure(input.raiseFromPremium),
+            tx.pure(input.raiseFromInactive),
             tx.object(constants_1.CLOCK),
         ],
     });
@@ -89,22 +89,22 @@ function getTokenReduceFundTx(config, tx, input) {
             tx.object(config.registry.typus.user),
             tx.object(config.registry.typus.leaderboard),
             tx.object(config.registry.dov.dovSingle),
-            tx.pure.u64(input.index),
+            tx.pure(input.index),
             tx.makeMoveVec({
                 type: "".concat(config.packageOrigin.framework, "::vault::TypusDepositReceipt"),
-                elements: input.receipts.map(function (receipt) { return tx.object(receipt); }),
+                objects: input.receipts.map(function (receipt) { return tx.object(receipt); }),
             }),
-            tx.pure.u64(input.reduceFromWarmup),
-            tx.pure.u64(input.reduceFromActive),
-            tx.pure.bool(input.reduceFromPremium),
-            tx.pure.bool(input.reduceFromInactive),
-            tx.pure.bool(input.reduceFromIncentive),
+            tx.pure(input.reduceFromWarmup),
+            tx.pure(input.reduceFromActive),
+            tx.pure(input.reduceFromPremium),
+            tx.pure(input.reduceFromInactive),
+            tx.pure(input.reduceFromIncentive),
             tx.object(constants_1.CLOCK),
         ],
     });
     tx.moveCall({
         target: "".concat(config.package.framework, "::vault::transfer_deposit_receipt"),
-        arguments: [tx.object(result[0]), tx.pure.address(input.user)],
+        arguments: [tx.object(result[0]), tx.pure(input.user)],
     });
     if (input.typeArguments[0] == input.typusTokenType) {
         var typusToken = tx.moveCall({
@@ -122,7 +122,7 @@ function getTokenReduceFundTx(config, tx, input) {
         tx.moveCall({
             target: "".concat(config.package.framework, "::utils::transfer_balance"),
             typeArguments: [input.typeArguments[0]],
-            arguments: [tx.object(result[1]), tx.pure.address(input.user)],
+            arguments: [tx.object(result[1]), tx.pure(input.user)],
         });
     }
     if (input.typeArguments[1] == input.typusTokenType) {
@@ -141,7 +141,7 @@ function getTokenReduceFundTx(config, tx, input) {
         tx.moveCall({
             target: "".concat(config.package.framework, "::utils::transfer_balance"),
             typeArguments: [input.typeArguments[1]],
-            arguments: [tx.object(result[2]), tx.pure.address(input.user)],
+            arguments: [tx.object(result[2]), tx.pure(input.user)],
         });
     }
     if (input.typeArguments[2] == input.typusTokenType) {
@@ -160,7 +160,7 @@ function getTokenReduceFundTx(config, tx, input) {
         tx.moveCall({
             target: "".concat(config.package.framework, "::utils::transfer_balance"),
             typeArguments: [input.typeArguments[2]],
-            arguments: [tx.object(result[3]), tx.pure.address(input.user)],
+            arguments: [tx.object(result[3]), tx.pure(input.user)],
         });
     }
     return tx;
@@ -185,8 +185,8 @@ function getTokenNewBidTx(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.premium_required),
+            tx.makeMoveVec({ objects: input.coins.map(function (id) { return tx.object(id); }) }),
+            tx.pure(input.premium_required),
         ],
     });
     var result = tx.moveCall({
@@ -198,10 +198,10 @@ function getTokenNewBidTx(config, tx, input) {
             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: [mToken] }),
-            tx.pure.u64(input.size),
-            tx.object(constants_1.CLOCK),
+            tx.pure(input.index),
+            tx.makeMoveVec({ objects: [mToken] }),
+            tx.pure(input.size),
+            tx.pure("0x6"),
         ],
     });
     tx.transferObjects([tx.object(result[0])], input.user);
@@ -233,10 +233,10 @@ function getTokenExerciseTx(config, tx, input) {
         typeArguments: input.typeArguments,
         arguments: [
             tx.object(config.registry.dov.dovSingle),
-            tx.pure.u64(input.index),
+            tx.pure(input.index),
             tx.makeMoveVec({
                 type: "".concat(config.packageOrigin.framework, "::vault::TypusBidReceipt"),
-                elements: input.receipts.map(function (receipt) { return tx.object(receipt); }),
+                objects: input.receipts.map(function (receipt) { return tx.object(receipt); }),
             }),
         ],
     });
@@ -304,14 +304,14 @@ function getTokenCompoundWithRedeemTx(config, tx, input) {
             tx.object(config.registry.typus.user),
             tx.object(config.registry.typus.leaderboard),
             tx.object(config.registry.dov.dovSingle),
-            tx.pure.u64(input.index),
+            tx.pure(input.index),
             tx.makeMoveVec({
                 type: "".concat(config.packageOrigin.framework, "::vault::TypusDepositReceipt"),
-                elements: input.receipts.map(function (receipt) { return tx.object(receipt); }),
+                objects: input.receipts.map(function (receipt) { return tx.object(receipt); }),
             }),
             tx.object(raiseBalance),
-            tx.pure.bool(true),
-            tx.pure.bool(false),
+            tx.pure(true),
+            tx.pure(false),
             tx.object(constants_1.CLOCK),
         ],
     });

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

@@ -1,4 +1,4 @@
-import { Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
+import { TransactionBlock, TransactionObjectArgument } from "@mysten/sui.js/transactions";
 import { TypusConfig } from "../../src/utils";
 /**
     public fun public_raise_fund<D_TOKEN, B_TOKEN>(
@@ -15,7 +15,7 @@ import { TypusConfig } from "../../src/utils";
         ctx: &mut TxContext,
     ): (TypusDepositReceipt, vector<u64>) {
  */
-export declare function getRaiseFundTx(config: TypusConfig, tx: Transaction, input: {
+export declare function getRaiseFundTx(config: TypusConfig, tx: TransactionBlock, input: {
     typeArguments: string[];
     index: string;
     receipts: string[] | TransactionObjectArgument[];
@@ -24,7 +24,7 @@ export declare function getRaiseFundTx(config: TypusConfig, tx: Transaction, inp
     raiseFromPremium: boolean;
     raiseFromInactive: boolean;
     user: string;
-}): Transaction;
+}): TransactionBlock;
 /**
     public fun public_reduce_fund<D_TOKEN, B_TOKEN, I_TOKEN>(
         typus_ecosystem_version: &TypusEcosystemVersion,
@@ -42,7 +42,7 @@ export declare function getRaiseFundTx(config: TypusConfig, tx: Transaction, inp
         ctx: &mut TxContext,
     ): (Option<TypusDepositReceipt>, Balance<D_TOKEN>, Balance<B_TOKEN>, Balance<I_TOKEN>, vector<u64>) {
  */
-export declare function getReduceFundTx(config: TypusConfig, tx: Transaction, input: {
+export declare function getReduceFundTx(config: TypusConfig, tx: TransactionBlock, input: {
     typeArguments: string[];
     index: string;
     receipts: string[] | TransactionObjectArgument[];
@@ -52,7 +52,7 @@ export declare function getReduceFundTx(config: TypusConfig, tx: Transaction, in
     reduceFromInactive: boolean;
     reduceFromIncentive: boolean;
     user: string;
-}): Transaction;
+}): TransactionBlock;
 /**
     public fun public_refresh_deposit_snapshot<D_TOKEN, B_TOKEN>(
         typus_ecosystem_version: &TypusEcosystemVersion,
@@ -65,12 +65,12 @@ export declare function getReduceFundTx(config: TypusConfig, tx: Transaction, in
         ctx: &mut TxContext,
     ): (TypusDepositReceipt, vector<u64>) {
  */
-export declare function getRefreshDepositSnapshotTx(config: TypusConfig, tx: Transaction, input: {
+export declare function getRefreshDepositSnapshotTx(config: TypusConfig, tx: TransactionBlock, input: {
     typeArguments: string[];
     index: string;
     receipts: string[] | TransactionObjectArgument[];
     user: string;
-}): Transaction;
+}): TransactionBlock;
 /**
     public(friend) entry fun new_bid<D_TOKEN, B_TOKEN>(
         registry: &mut Registry,
@@ -81,7 +81,7 @@ export declare function getRefreshDepositSnapshotTx(config: TypusConfig, tx: Tra
         ctx: &mut TxContext,
     )
 */
-export declare function getNewBidTx(config: TypusConfig, tx: Transaction, input: {
+export declare function getNewBidTx(config: TypusConfig, tx: TransactionBlock, input: {
     typeArguments: string[];
     index: string;
     coins: string[];
@@ -89,7 +89,7 @@ export declare function getNewBidTx(config: TypusConfig, tx: Transaction, input:
     premium_required: string;
     user: string;
     usingSponsoredGasCoin?: boolean;
-}): Transaction;
+}): TransactionBlock;
 /**
     public(friend) entry fun exercise<D_TOKEN, B_TOKEN>(
         registry: &mut Registry,
@@ -98,12 +98,12 @@ export declare function getNewBidTx(config: TypusConfig, tx: Transaction, input:
         ctx: &mut TxContext,
     )
 */
-export declare function getExerciseTx(config: TypusConfig, tx: Transaction, input: {
+export declare function getExerciseTx(config: TypusConfig, tx: TransactionBlock, input: {
     typeArguments: string[];
     index: string;
     receipts: string[] | TransactionObjectArgument[];
     user: string;
-}): Transaction;
+}): TransactionBlock;
 /**
     public(friend) entry fun transfer_bid_receipt<D_TOKEN, B_TOKEN>(
         registry: &mut Registry,
@@ -114,19 +114,19 @@ export declare function getExerciseTx(config: TypusConfig, tx: Transaction, inpu
         ctx: &mut TxContext,
     ) {
 */
-export declare function getTransferBidReceiptTx(config: TypusConfig, tx: Transaction, input: {
+export declare function getTransferBidReceiptTx(config: TypusConfig, tx: TransactionBlock, input: {
     typeArguments: string[];
     index: string;
     receipts: string[];
     share?: string;
     recipient: string;
-}): Transaction;
-export declare function getSplitBidReceiptTx(config: TypusConfig, tx: Transaction, input: {
+}): TransactionBlock;
+export declare function getSplitBidReceiptTx(config: TypusConfig, tx: TransactionBlock, input: {
     index: string;
     receipts: string[];
     share: string;
     recipient: string;
-}): import("@mysten/sui/transactions").TransactionResult;
+}): import("@mysten/sui.js/transactions").TransactionResult;
 export declare function getMultiTransferBidReceiptTx(config: TypusConfig, input: {
     typeArguments: string[];
     index: string;
@@ -134,20 +134,20 @@ export declare function getMultiTransferBidReceiptTx(config: TypusConfig, input:
     shares: string[];
     recipients: string[];
     sender: string;
-}): Transaction;
+}): TransactionBlock;
 /**
     public(friend) entry fun refund<TOKEN>(
         registry: &mut Registry,
         ctx: &mut TxContext,
     )
 */
-export declare function getRebateTx(config: TypusConfig, tx: Transaction, input: {
+export declare function getRebateTx(config: TypusConfig, tx: TransactionBlock, input: {
     typeArgument: string;
     user: string;
-}): Transaction;
-export declare function getCompoundWithRedeemTx(config: TypusConfig, tx: Transaction, input: {
+}): TransactionBlock;
+export declare function getCompoundWithRedeemTx(config: TypusConfig, tx: TransactionBlock, input: {
     typeArguments: string[];
     index: string;
     receipts: string[] | TransactionObjectArgument[];
     user: string;
-}): Transaction;
+}): TransactionBlock;

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

@@ -26,8 +26,7 @@ exports.getSplitBidReceiptTx = getSplitBidReceiptTx;
 exports.getMultiTransferBidReceiptTx = getMultiTransferBidReceiptTx;
 exports.getRebateTx = getRebateTx;
 exports.getCompoundWithRedeemTx = getCompoundWithRedeemTx;
-var bcs_1 = require("@mysten/sui/bcs");
-var transactions_1 = require("@mysten/sui/transactions");
+var transactions_1 = require("@mysten/sui.js/transactions");
 var constants_1 = require("../../src/constants");
 /**
     public fun public_raise_fund<D_TOKEN, B_TOKEN>(
@@ -51,24 +50,24 @@ function getRaiseFundTx(config, tx, input) {
             target: "".concat(config.package.framework, "::utils::delegate_extract_balance"),
             typeArguments: [input.typeArguments[0]],
             arguments: [
-                tx.pure.address(input.user),
+                tx.pure(input.user),
                 tx.makeMoveVec({
                     type: "0x2::coin::Coin<".concat(input.typeArguments[0], ">"),
-                    elements: [tx.splitCoins(tx.gas, [tx.pure.u64(input.raiseAmount)])],
+                    objects: [tx.splitCoins(tx.gas, [tx.pure(input.raiseAmount)])],
                 }),
-                tx.pure.u64(input.raiseAmount),
+                tx.pure(input.raiseAmount),
             ],
         })
         : tx.moveCall({
             target: "".concat(config.package.framework, "::utils::delegate_extract_balance"),
             typeArguments: [input.typeArguments[0]],
             arguments: [
-                tx.pure.address(input.user),
+                tx.pure(input.user),
                 tx.makeMoveVec({
                     type: "0x2::coin::Coin<".concat(input.typeArguments[0], ">"),
-                    elements: input.raiseCoins.map(function (coin) { return tx.object(coin); }),
+                    objects: input.raiseCoins.map(function (coin) { return tx.object(coin); }),
                 }),
-                tx.pure.u64(input.raiseAmount),
+                tx.pure(input.raiseAmount),
             ],
         });
     var result = tx.moveCall({
@@ -79,14 +78,14 @@ function getRaiseFundTx(config, tx, input) {
             tx.object(config.registry.typus.user),
             tx.object(config.registry.typus.leaderboard),
             tx.object(config.registry.dov.dovSingle),
-            tx.pure.u64(input.index),
+            tx.pure(input.index),
             tx.makeMoveVec({
                 type: "".concat(config.packageOrigin.framework, "::vault::TypusDepositReceipt"),
-                elements: input.receipts.map(function (receipt) { return tx.object(receipt); }),
+                objects: input.receipts.map(function (receipt) { return tx.object(receipt); }),
             }),
             tx.object(raiseBalance),
-            tx.pure.bool(input.raiseFromPremium),
-            tx.pure.bool(input.raiseFromInactive),
+            tx.pure(input.raiseFromPremium),
+            tx.pure(input.raiseFromInactive),
             tx.object(constants_1.CLOCK),
         ],
     });
@@ -119,37 +118,37 @@ function getReduceFundTx(config, tx, input) {
             tx.object(config.registry.typus.user),
             tx.object(config.registry.typus.leaderboard),
             tx.object(config.registry.dov.dovSingle),
-            tx.pure.u64(input.index),
+            tx.pure(input.index),
             tx.makeMoveVec({
                 type: "".concat(config.packageOrigin.framework, "::vault::TypusDepositReceipt"),
-                elements: input.receipts.map(function (receipt) { return tx.object(receipt); }),
+                objects: input.receipts.map(function (receipt) { return tx.object(receipt); }),
             }),
-            tx.pure.u64(input.reduceFromWarmup),
-            tx.pure.u64(input.reduceFromActive),
-            tx.pure.bool(input.reduceFromPremium),
-            tx.pure.bool(input.reduceFromInactive),
-            tx.pure.bool(input.reduceFromIncentive),
+            tx.pure(input.reduceFromWarmup),
+            tx.pure(input.reduceFromActive),
+            tx.pure(input.reduceFromPremium),
+            tx.pure(input.reduceFromInactive),
+            tx.pure(input.reduceFromIncentive),
             tx.object(constants_1.CLOCK),
         ],
     });
     tx.moveCall({
         target: "".concat(config.package.framework, "::vault::transfer_deposit_receipt"),
-        arguments: [tx.object(result[0]), tx.pure.address(input.user)],
+        arguments: [tx.object(result[0]), tx.pure(input.user)],
     });
     tx.moveCall({
         target: "".concat(config.package.framework, "::utils::transfer_balance"),
         typeArguments: [input.typeArguments[0]],
-        arguments: [tx.object(result[1]), tx.pure.address(input.user)],
+        arguments: [tx.object(result[1]), tx.pure(input.user)],
     });
     tx.moveCall({
         target: "".concat(config.package.framework, "::utils::transfer_balance"),
         typeArguments: [input.typeArguments[1]],
-        arguments: [tx.object(result[2]), tx.pure.address(input.user)],
+        arguments: [tx.object(result[2]), tx.pure(input.user)],
     });
     tx.moveCall({
         target: "".concat(config.package.framework, "::utils::transfer_balance"),
         typeArguments: [input.typeArguments[2]],
-        arguments: [tx.object(result[3]), tx.pure.address(input.user)],
+        arguments: [tx.object(result[3]), tx.pure(input.user)],
     });
     return tx;
 }
@@ -174,10 +173,10 @@ function getRefreshDepositSnapshotTx(config, tx, input) {
             tx.object(config.registry.typus.user),
             tx.object(config.registry.typus.leaderboard),
             tx.object(config.registry.dov.dovSingle),
-            tx.pure.u64(input.index),
+            tx.pure(input.index),
             tx.makeMoveVec({
                 type: "".concat(config.packageOrigin.framework, "::vault::TypusDepositReceipt"),
-                elements: input.receipts.map(function (receipt) { return tx.object(receipt); }),
+                objects: input.receipts.map(function (receipt) { return tx.object(receipt); }),
             }),
             tx.object(constants_1.CLOCK),
         ],
@@ -199,7 +198,7 @@ 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 _a = __read(tx.splitCoins(tx.gas, [tx.pure(input.premium_required)]), 1), coin = _a[0];
         var result = tx.moveCall({
             target: "".concat(config.package.dovSingle, "::tds_user_entry::public_bid"),
             typeArguments: input.typeArguments,
@@ -209,9 +208,9 @@ function getNewBidTx(config, tx, input) {
                 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.pure(input.index),
+                tx.makeMoveVec({ objects: [coin] }),
+                tx.pure(input.size),
                 tx.object(constants_1.CLOCK),
             ],
         });
@@ -219,14 +218,14 @@ function getNewBidTx(config, tx, input) {
         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)],
+            arguments: [tx.makeMoveVec({ objects: [tx.object(result[1])] }), tx.pure(input.user)],
         });
     }
     else {
         var balance = tx.moveCall({
             target: "".concat(config.package.framework, "::utils::extract_balance"),
             typeArguments: [input.typeArguments[1]],
-            arguments: [tx.makeMoveVec({ elements: input.coins.map(function (coin) { return tx.object(coin); }) }), tx.pure.u64(input.premium_required)],
+            arguments: [tx.makeMoveVec({ objects: input.coins.map(function (coin) { return tx.object(coin); }) }), tx.pure(input.premium_required)],
         });
         var coin = tx.moveCall({
             target: "0x2::coin::from_balance",
@@ -242,17 +241,17 @@ function getNewBidTx(config, tx, input) {
                 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.pure(input.index),
+                tx.makeMoveVec({ objects: [coin] }),
+                tx.pure(input.size),
+                tx.pure("0x6"),
             ],
         });
         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)],
+            arguments: [tx.makeMoveVec({ objects: [tx.object(result[1])] }), tx.pure(input.user)],
         });
     }
     return tx;
@@ -271,17 +270,17 @@ function getExerciseTx(config, tx, input) {
         typeArguments: input.typeArguments,
         arguments: [
             tx.object(config.registry.dov.dovSingle),
-            tx.pure.u64(input.index),
+            tx.pure(input.index),
             tx.makeMoveVec({
                 type: "".concat(config.packageOrigin.framework, "::vault::TypusBidReceipt"),
-                elements: input.receipts.map(function (receipt) { return tx.object(receipt); }),
+                objects: input.receipts.map(function (receipt) { return tx.object(receipt); }),
             }),
         ],
     });
     tx.moveCall({
         target: "".concat(config.package.framework, "::utils::transfer_balance"),
         typeArguments: [input.typeArguments[0]],
-        arguments: [tx.object(result[0]), tx.pure.address(input.user)],
+        arguments: [tx.object(result[0]), tx.pure(input.user)],
     });
     return tx;
 }
@@ -301,13 +300,13 @@ function getTransferBidReceiptTx(config, tx, input) {
         typeArguments: input.typeArguments,
         arguments: [
             tx.object(config.registry.dov.dovSingle),
-            tx.pure.u64(input.index),
+            tx.pure(input.index),
             tx.makeMoveVec({
                 type: "".concat(config.packageOrigin.framework, "::vault::TypusBidReceipt"),
-                elements: input.receipts.map(function (receipt) { return tx.object(receipt); }),
+                objects: input.receipts.map(function (receipt) { return tx.object(receipt); }),
             }),
-            tx.pure.option("u64", input.share),
-            tx.pure.address(input.recipient),
+            tx.pure(input.share ? [input.share] : []),
+            tx.pure(input.recipient),
         ],
     });
     return tx;
@@ -318,13 +317,12 @@ function getSplitBidReceiptTx(config, tx, input) {
         typeArguments: [],
         arguments: [
             tx.object(config.registry.dov.dovSingle),
-            tx.pure.u64(input.index),
+            tx.pure(input.index),
             tx.makeMoveVec({
                 type: "".concat(config.packageOrigin.framework, "::vault::TypusBidReceipt"),
-                elements: input.receipts.map(function (receipt) { return tx.object(receipt); }),
+                objects: input.receipts.map(function (receipt) { return tx.object(receipt); }),
             }),
-            // tx.pure([input.share]),
-            tx.pure(bcs_1.bcs.vector(bcs_1.bcs.U64).serialize([input.share])),
+            tx.pure([input.share]),
         ],
     });
     var unwrap0 = tx.moveCall({
@@ -341,12 +339,12 @@ function getSplitBidReceiptTx(config, tx, input) {
     return unwrap0;
 }
 function getMultiTransferBidReceiptTx(config, input) {
-    var tx = new transactions_1.Transaction();
+    var tx = new transactions_1.TransactionBlock();
     console.assert(input.shares.length == input.recipients.length, "shares.length != recipients.length");
-    var receipts = tx.makeMoveVec({
+    var receipts = {
         // type: `${config.packageOrigin.framework}::vault::TypusBidReceipt`,
-        elements: input.receipts.map(function (receipt) { return tx.object(receipt); }),
-    });
+        objects: input.receipts.map(function (receipt) { return tx.object(receipt); }),
+    };
     var i = 0;
     while (i < input.shares.length) {
         var share = input.shares[i];
@@ -356,10 +354,10 @@ function getMultiTransferBidReceiptTx(config, input) {
             typeArguments: input.typeArguments,
             arguments: [
                 tx.object(config.registry.dov.dovSingle),
-                tx.pure.u64(input.index),
-                receipts,
-                tx.pure.option("u64", share),
-                tx.pure.address(recipient),
+                tx.pure(input.index),
+                tx.makeMoveVec(receipts),
+                tx.pure([share]),
+                tx.pure(recipient),
             ],
         });
         var unwrap = tx.moveCall({
@@ -367,7 +365,7 @@ function getMultiTransferBidReceiptTx(config, input) {
             typeArguments: ["".concat(config.packageOrigin.framework, "::vault::TypusBidReceipt")],
             arguments: [tx.object(result[0])],
         });
-        receipts = tx.makeMoveVec({ elements: [unwrap] });
+        receipts = { objects: [unwrap] };
         i += 1;
         if (i == input.shares.length) {
             tx.transferObjects([tx.object(unwrap)], input.sender);
@@ -395,7 +393,7 @@ function getRebateTx(config, tx, input) {
     tx.moveCall({
         target: "".concat(config.package.framework, "::utils::transfer_balance"),
         typeArguments: [input.typeArgument],
-        arguments: [tx.object(balance), tx.pure.address(input.user)],
+        arguments: [tx.object(balance), tx.pure(input.user)],
     });
     return tx;
 }
@@ -413,14 +411,14 @@ function getCompoundWithRedeemTx(config, tx, input) {
             tx.object(config.registry.typus.user),
             tx.object(config.registry.typus.leaderboard),
             tx.object(config.registry.dov.dovSingle),
-            tx.pure.u64(input.index),
+            tx.pure(input.index),
             tx.makeMoveVec({
                 type: "".concat(config.packageOrigin.framework, "::vault::TypusDepositReceipt"),
-                elements: input.receipts.map(function (receipt) { return tx.object(receipt); }),
+                objects: input.receipts.map(function (receipt) { return tx.object(receipt); }),
             }),
             tx.object(raiseBalance),
-            tx.pure.bool(true),
-            tx.pure.bool(false),
+            tx.pure(true),
+            tx.pure(false),
             tx.object(constants_1.CLOCK),
         ],
     });