@typus/typus-sdk 1.4.84 → 1.5.1

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({ objects: input.raiseCoins }),
-                        tx.pure(input.raiseAmount),
+                        tx.makeMoveVec({ elements: input.raiseCoins }),
+                        tx.pure.u64(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(input.index),
+            tx.pure.u64(input.index),
             tx.makeMoveVec({
                 type: "".concat(config.packageOrigin.framework, "::vault::TypusDepositReceipt"),
-                objects: input.receipts.map(function (receipt) { return tx.object(receipt); }),
+                elements: input.receipts.map(function (receipt) { return tx.object(receipt); }),
             }),
             tx.object(typusTokenBalance),
-            tx.pure(input.raiseFromPremium),
-            tx.pure(input.raiseFromInactive),
+            tx.pure.bool(input.raiseFromPremium),
+            tx.pure.bool(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(input.index),
+            tx.pure.u64(input.index),
             tx.makeMoveVec({
                 type: "".concat(config.packageOrigin.framework, "::vault::TypusDepositReceipt"),
-                objects: input.receipts.map(function (receipt) { return tx.object(receipt); }),
+                elements: input.receipts.map(function (receipt) { return tx.object(receipt); }),
             }),
-            tx.pure(input.reduceFromWarmup),
-            tx.pure(input.reduceFromActive),
-            tx.pure(input.reduceFromPremium),
-            tx.pure(input.reduceFromInactive),
-            tx.pure(input.reduceFromIncentive),
+            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.object(constants_1.CLOCK),
         ],
     });
     tx.moveCall({
         target: "".concat(config.package.framework, "::vault::transfer_deposit_receipt"),
-        arguments: [tx.object(result[0]), tx.pure(input.user)],
+        arguments: [tx.object(result[0]), tx.pure.address(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(input.user)],
+            arguments: [tx.object(result[1]), tx.pure.address(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(input.user)],
+            arguments: [tx.object(result[2]), tx.pure.address(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(input.user)],
+            arguments: [tx.object(result[3]), tx.pure.address(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({ objects: input.coins.map(function (id) { return tx.object(id); }) }),
-            tx.pure(input.premium_required),
+            tx.makeMoveVec({ elements: input.coins.map(function (id) { return tx.object(id); }) }),
+            tx.pure.u64(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(input.index),
-            tx.makeMoveVec({ objects: [mToken] }),
-            tx.pure(input.size),
-            tx.pure("0x6"),
+            tx.pure.u64(input.index),
+            tx.makeMoveVec({ elements: [mToken] }),
+            tx.pure.u64(input.size),
+            tx.object(constants_1.CLOCK),
         ],
     });
     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(input.index),
+            tx.pure.u64(input.index),
             tx.makeMoveVec({
                 type: "".concat(config.packageOrigin.framework, "::vault::TypusBidReceipt"),
-                objects: input.receipts.map(function (receipt) { return tx.object(receipt); }),
+                elements: 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(input.index),
+            tx.pure.u64(input.index),
             tx.makeMoveVec({
                 type: "".concat(config.packageOrigin.framework, "::vault::TypusDepositReceipt"),
-                objects: input.receipts.map(function (receipt) { return tx.object(receipt); }),
+                elements: input.receipts.map(function (receipt) { return tx.object(receipt); }),
             }),
             tx.object(raiseBalance),
-            tx.pure(true),
-            tx.pure(false),
+            tx.pure.bool(true),
+            tx.pure.bool(false),
             tx.object(constants_1.CLOCK),
         ],
     });

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

@@ -1,4 +1,4 @@
-import { TransactionBlock, TransactionObjectArgument } from "@mysten/sui.js/transactions";
+import { Transaction, TransactionObjectArgument } from "@mysten/sui/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: TransactionBlock, input: {
+export declare function getRaiseFundTx(config: TypusConfig, tx: Transaction, input: {
     typeArguments: string[];
     index: string;
     receipts: string[] | TransactionObjectArgument[];
@@ -24,7 +24,7 @@ export declare function getRaiseFundTx(config: TypusConfig, tx: TransactionBlock
     raiseFromPremium: boolean;
     raiseFromInactive: boolean;
     user: string;
-}): TransactionBlock;
+}): Transaction;
 /**
     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: TransactionBlock
         ctx: &mut TxContext,
     ): (Option<TypusDepositReceipt>, Balance<D_TOKEN>, Balance<B_TOKEN>, Balance<I_TOKEN>, vector<u64>) {
  */
-export declare function getReduceFundTx(config: TypusConfig, tx: TransactionBlock, input: {
+export declare function getReduceFundTx(config: TypusConfig, tx: Transaction, input: {
     typeArguments: string[];
     index: string;
     receipts: string[] | TransactionObjectArgument[];
@@ -52,7 +52,7 @@ export declare function getReduceFundTx(config: TypusConfig, tx: TransactionBloc
     reduceFromInactive: boolean;
     reduceFromIncentive: boolean;
     user: string;
-}): TransactionBlock;
+}): Transaction;
 /**
     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: TransactionBloc
         ctx: &mut TxContext,
     ): (TypusDepositReceipt, vector<u64>) {
  */
-export declare function getRefreshDepositSnapshotTx(config: TypusConfig, tx: TransactionBlock, input: {
+export declare function getRefreshDepositSnapshotTx(config: TypusConfig, tx: Transaction, input: {
     typeArguments: string[];
     index: string;
     receipts: string[] | TransactionObjectArgument[];
     user: string;
-}): TransactionBlock;
+}): Transaction;
 /**
     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: TransactionBlock, input: {
+export declare function getNewBidTx(config: TypusConfig, tx: Transaction, input: {
     typeArguments: string[];
     index: string;
     coins: string[];
@@ -89,7 +89,7 @@ export declare function getNewBidTx(config: TypusConfig, tx: TransactionBlock, i
     premium_required: string;
     user: string;
     usingSponsoredGasCoin?: boolean;
-}): TransactionBlock;
+}): Transaction;
 /**
     public(friend) entry fun exercise<D_TOKEN, B_TOKEN>(
         registry: &mut Registry,
@@ -98,12 +98,12 @@ export declare function getNewBidTx(config: TypusConfig, tx: TransactionBlock, i
         ctx: &mut TxContext,
     )
 */
-export declare function getExerciseTx(config: TypusConfig, tx: TransactionBlock, input: {
+export declare function getExerciseTx(config: TypusConfig, tx: Transaction, input: {
     typeArguments: string[];
     index: string;
     receipts: string[] | TransactionObjectArgument[];
     user: string;
-}): TransactionBlock;
+}): Transaction;
 /**
     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: TransactionBlock,
         ctx: &mut TxContext,
     ) {
 */
-export declare function getTransferBidReceiptTx(config: TypusConfig, tx: TransactionBlock, input: {
+export declare function getTransferBidReceiptTx(config: TypusConfig, tx: Transaction, input: {
     typeArguments: string[];
     index: string;
     receipts: string[];
     share?: string;
     recipient: string;
-}): TransactionBlock;
-export declare function getSplitBidReceiptTx(config: TypusConfig, tx: TransactionBlock, input: {
+}): Transaction;
+export declare function getSplitBidReceiptTx(config: TypusConfig, tx: Transaction, input: {
     index: string;
     receipts: string[];
     share: string;
     recipient: string;
-}): import("@mysten/sui.js/transactions").TransactionResult;
+}): import("@mysten/sui/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;
-}): TransactionBlock;
+}): Transaction;
 /**
     public(friend) entry fun refund<TOKEN>(
         registry: &mut Registry,
         ctx: &mut TxContext,
     )
 */
-export declare function getRebateTx(config: TypusConfig, tx: TransactionBlock, input: {
+export declare function getRebateTx(config: TypusConfig, tx: Transaction, input: {
     typeArgument: string;
     user: string;
-}): TransactionBlock;
-export declare function getCompoundWithRedeemTx(config: TypusConfig, tx: TransactionBlock, input: {
+}): Transaction;
+export declare function getCompoundWithRedeemTx(config: TypusConfig, tx: Transaction, input: {
     typeArguments: string[];
     index: string;
     receipts: string[] | TransactionObjectArgument[];
     user: string;
-}): TransactionBlock;
+}): Transaction;

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

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