@typus/typus-sdk 1.2.588 → 1.3.1

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

@@ -16,416 +16,168 @@ var __read = (this && this.__read) || function (o, n) {
     return ar;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRebateTx = exports.getMultiTransferBidReceiptTx = exports.getTransferBidReceiptTx = exports.getExerciseTx = exports.getNewBidTx = exports.getWithdrawHarvestClaimTx = exports.getRedeemTx = exports.getHarvestTx = exports.getClaimTx = exports.getCompoundTx = exports.getUnsubscribeTx = exports.getWithdrawTx = exports.getDepositTx = void 0;
+exports.getCompoundWithRedeemTx = exports.getRebateTx = exports.getMultiTransferBidReceiptTx = exports.getTransferBidReceiptTx = exports.getExerciseTx = exports.getNewBidTx = exports.getRefreshDepositSnapshotTx = exports.getReduceFundTx = exports.getRaiseFundTx = void 0;
 var transactions_1 = require("@mysten/sui.js/transactions");
 var constants_1 = require("../../constants");
 /**
-    public fun deposit<D_TOKEN, B_TOKEN>(
+    public fun public_raise_fund<D_TOKEN, B_TOKEN>(
+        typus_ecosystem_version: &TypusEcosystemVersion,
+        typus_user_registry: &mut TypusUserRegistry,
+        typus_leaderboard_registry: &mut TypusLeaderboardRegistry,
         registry: &mut Registry,
         index: u64,
-        coins: vector<Coin<D_TOKEN>>,
-        amount: u64,
         receipts: vector<TypusDepositReceipt>,
+        raise_balance: Balance<D_TOKEN>,
+        raise_from_premium: bool,
+        raise_from_inactive: bool,
         clock: &Clock,
         ctx: &mut TxContext,
-    )
-*/
-function getDepositTx(input) {
-    if (!input.usingSponsoredGasCoin &&
-        (input.typeArguments[0] == "0x2::sui::SUI" ||
-            input.typeArguments[0] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI")) {
-        var _a = __read(input.tx.splitCoins(input.tx.gas, [input.tx.pure(input.amount)]), 1), coin = _a[0];
-        var result = input.tx.moveCall({
-            target: "".concat(input.typusDovSinglePackageId, "::tails_staking::deposit"),
-            typeArguments: input.typeArguments,
+    ): (TypusDepositReceipt, vector<u64>) {
+ */
+function getRaiseFundTx(input) {
+    var raiseBalance = input.typeArguments[0] == "0x2::sui::SUI" ||
+        input.typeArguments[0] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI"
+        ? input.tx.moveCall({
+            target: "".concat(input.typusFrameworkPackageId, "::utils::delegate_extract_balance"),
+            typeArguments: [input.typeArguments[0]],
             arguments: [
-                input.tx.object(input.typusDovSingleRegistry),
-                input.tx.pure(input.index),
-                input.tx.makeMoveVec({ objects: [coin] }),
-                input.tx.pure(input.amount),
+                input.tx.pure(input.user),
                 input.tx.makeMoveVec({
-                    type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
-                    objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
+                    type: "0x2::coin::Coin<".concat(input.typeArguments[0], ">"),
+                    objects: [input.tx.splitCoins(input.tx.gas, [input.tx.pure(input.raiseAmount)])],
                 }),
-                input.tx.pure(constants_1.CLOCK),
+                input.tx.pure(input.raiseAmount),
             ],
-        });
-        input.tx.moveCall({
-            target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_coins"),
+        })
+        : input.tx.moveCall({
+            target: "".concat(input.typusFrameworkPackageId, "::utils::delegate_extract_balance"),
             typeArguments: [input.typeArguments[0]],
-            arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
-        });
-        input.tx.transferObjects([input.tx.object(result[1])], input.user);
-    }
-    else {
-        var result = input.tx.moveCall({
-            target: "".concat(input.typusDovSinglePackageId, "::tails_staking::deposit"),
-            typeArguments: input.typeArguments,
             arguments: [
-                input.tx.object(input.typusDovSingleRegistry),
-                input.tx.pure(input.index),
-                input.tx.makeMoveVec({ objects: input.coins.map(function (coin) { return input.tx.object(coin); }) }),
-                input.tx.pure(input.amount),
+                input.tx.pure(input.user),
                 input.tx.makeMoveVec({
-                    type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
-                    objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
+                    type: "0x2::coin::Coin<".concat(input.typeArguments[0], ">"),
+                    objects: input.raiseCoins.map(function (coin) { return input.tx.object(coin); }),
                 }),
-                input.tx.pure(constants_1.CLOCK),
+                input.tx.pure(input.raiseAmount),
             ],
         });
-        input.tx.moveCall({
-            target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_coins"),
-            typeArguments: [input.typeArguments[0]],
-            arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
-        });
-        input.tx.transferObjects([input.tx.object(result[1])], input.user);
-    }
-    return input.tx;
-}
-exports.getDepositTx = getDepositTx;
-/**
-    public fun withdraw<D_TOKEN, B_TOKEN>(
-        registry: &mut Registry,
-        index: u64,
-        receipts: vector<TypusDepositReceipt>,
-        share: Option<u64>,
-        clock: &Clock,
-        ctx: &mut TxContext,
-    )
-*/
-function getWithdrawTx(input) {
-    var result = input.tx.moveCall({
-        target: "".concat(input.typusDovSinglePackageId, "::tails_staking::withdraw"),
-        typeArguments: input.typeArguments,
-        arguments: [
-            input.tx.object(input.typusDovSingleRegistry),
-            input.tx.pure(input.index),
-            input.tx.makeMoveVec({
-                type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
-                objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
-            }),
-            input.tx.pure(input.share ? [input.share] : []),
-            input.tx.pure(constants_1.CLOCK),
-        ],
-    });
-    input.tx.moveCall({
-        target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
-        typeArguments: [input.typeArguments[0]],
-        arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
-    });
-    input.tx.moveCall({
-        target: "".concat(input.typusFrameworkPackageId, "::vault::transfer_deposit_receipt"),
-        arguments: [input.tx.object(result[1]), input.tx.pure(input.user)],
-    });
-    return input.tx;
-}
-exports.getWithdrawTx = getWithdrawTx;
-/**
-    public fun unsubscribe<D_TOKEN, B_TOKEN>(
-        registry: &mut Registry,
-        index: u64,
-        receipts: vector<TypusDepositReceipt>,
-        share: Option<u64>,
-        clock: &Clock,
-        ctx: &mut TxContext,
-    )
-*/
-function getUnsubscribeTx(input) {
     var result = input.tx.moveCall({
-        target: "".concat(input.typusDovSinglePackageId, "::tails_staking::unsubscribe"),
+        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::public_raise_fund"),
         typeArguments: input.typeArguments,
         arguments: [
+            input.tx.object(input.typusEcosystemVersion),
+            input.tx.object(input.typusUserRegistry),
+            input.tx.object(input.typusLeaderboardRegistry),
             input.tx.object(input.typusDovSingleRegistry),
             input.tx.pure(input.index),
             input.tx.makeMoveVec({
                 type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
                 objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
             }),
-            input.tx.pure(input.share ? [input.share] : []),
-            input.tx.pure(constants_1.CLOCK),
+            input.tx.object(raiseBalance),
+            input.tx.pure(input.raiseFromPremium),
+            input.tx.pure(input.raiseFromInactive),
+            input.tx.object(constants_1.CLOCK),
         ],
     });
     input.tx.transferObjects([input.tx.object(result[0])], input.user);
     return input.tx;
 }
-exports.getUnsubscribeTx = getUnsubscribeTx;
+exports.getRaiseFundTx = getRaiseFundTx;
 /**
-    public fun compound<D_TOKEN, B_TOKEN>(
+    public fun public_reduce_fund<D_TOKEN, B_TOKEN, I_TOKEN>(
+        typus_ecosystem_version: &TypusEcosystemVersion,
+        typus_user_registry: &mut TypusUserRegistry,
+        typus_leaderboard_registry: &mut TypusLeaderboardRegistry,
         registry: &mut Registry,
         index: u64,
         receipts: vector<TypusDepositReceipt>,
+        reduce_from_warmup: u64,
+        reduce_from_active: u64,
+        reduce_from_premium: bool,
+        reduce_from_inactive: bool,
+        reduce_from_incentive: bool,
         clock: &Clock,
         ctx: &mut TxContext,
-    )
-*/
-function getCompoundTx(input) {
+    ): (Option<TypusDepositReceipt>, Balance<D_TOKEN>, Balance<B_TOKEN>, Balance<I_TOKEN>, vector<u64>) {
+ */
+function getReduceFundTx(input) {
     var result = input.tx.moveCall({
-        target: "".concat(input.typusDovSinglePackageId, "::tails_staking::compound"),
+        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::public_reduce_fund"),
         typeArguments: input.typeArguments,
         arguments: [
+            input.tx.object(input.typusEcosystemVersion),
+            input.tx.object(input.typusUserRegistry),
+            input.tx.object(input.typusLeaderboardRegistry),
             input.tx.object(input.typusDovSingleRegistry),
             input.tx.pure(input.index),
             input.tx.makeMoveVec({
                 type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
                 objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
             }),
+            input.tx.pure(input.reduceFromWarmup),
+            input.tx.pure(input.reduceFromActive),
+            input.tx.pure(input.reduceFromPremium),
+            input.tx.pure(input.reduceFromInactive),
+            input.tx.pure(input.reduceFromIncentive),
             input.tx.object(constants_1.CLOCK),
         ],
     });
-    if (input.incentiveToken) {
-        input.typeArguments.push(input.incentiveToken);
-        input.tx = getRedeemTx({
-            tx: input.tx,
-            typusFrameworkOriginPackageId: input.typusFrameworkOriginPackageId,
-            typusFrameworkPackageId: input.typusFrameworkPackageId,
-            typusDovSinglePackageId: input.typusDovSinglePackageId,
-            typusDovSingleRegistry: input.typusDovSingleRegistry,
-            typeArguments: input.typeArguments,
-            index: input.index,
-            receipts: [input.tx.object(result[0])],
-            user: input.user,
-        });
-    }
-    else {
-        input.tx.transferObjects([input.tx.object(result[0])], input.user);
-    }
-    return input.tx;
-}
-exports.getCompoundTx = getCompoundTx;
-/**
-    public fun claim<D_TOKEN, B_TOKEN>(
-        registry: &mut Registry,
-        index: u64,
-        receipts: vector<TypusDepositReceipt>,
-        ctx: &mut TxContext,
-    )
-*/
-function getClaimTx(input) {
-    var result = input.tx.moveCall({
-        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::claim"),
-        typeArguments: input.typeArguments,
-        arguments: [
-            input.tx.object(input.typusDovSingleRegistry),
-            input.tx.pure(input.index),
-            input.tx.makeMoveVec({
-                type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
-                objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
-            }),
-        ],
-    });
     input.tx.moveCall({
-        target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
-        typeArguments: [input.typeArguments[0]],
+        target: "".concat(input.typusFrameworkPackageId, "::vault::transfer_deposit_receipt"),
         arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
     });
     input.tx.moveCall({
-        target: "".concat(input.typusFrameworkPackageId, "::vault::transfer_deposit_receipt"),
+        target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
+        typeArguments: [input.typeArguments[0]],
         arguments: [input.tx.object(result[1]), input.tx.pure(input.user)],
     });
-    return input.tx;
-}
-exports.getClaimTx = getClaimTx;
-/**
-    public fun harvest<D_TOKEN, B_TOKEN>(
-        registry: &mut Registry,
-        index: u64,
-        receipts: vector<TypusDepositReceipt>,
-        ctx: &mut TxContext,
-    )
-*/
-function getHarvestTx(input) {
-    var result = input.tx.moveCall({
-        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::harvest"),
-        typeArguments: input.typeArguments,
-        arguments: [
-            input.tx.object(input.typusDovSingleRegistry),
-            input.tx.pure(input.index),
-            input.tx.makeMoveVec({
-                type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
-                objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
-            }),
-        ],
-    });
     input.tx.moveCall({
         target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
         typeArguments: [input.typeArguments[1]],
-        arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
+        arguments: [input.tx.object(result[2]), input.tx.pure(input.user)],
+    });
+    input.tx.moveCall({
+        target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
+        typeArguments: [input.typeArguments[2]],
+        arguments: [input.tx.object(result[3]), input.tx.pure(input.user)],
     });
-    if (input.incentiveToken) {
-        input.typeArguments.push(input.incentiveToken);
-        var receipt = input.tx.moveCall({
-            target: "0x1::option::destroy_some",
-            typeArguments: ["".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt")],
-            arguments: [input.tx.object(result[1])],
-        });
-        input.tx = getRedeemTx({
-            tx: input.tx,
-            typusFrameworkOriginPackageId: input.typusFrameworkOriginPackageId,
-            typusFrameworkPackageId: input.typusFrameworkPackageId,
-            typusDovSinglePackageId: input.typusDovSinglePackageId,
-            typusDovSingleRegistry: input.typusDovSingleRegistry,
-            typeArguments: input.typeArguments,
-            index: input.index,
-            receipts: [input.tx.object(receipt)],
-            user: input.user,
-        });
-    }
-    else {
-        input.tx.moveCall({
-            target: "".concat(input.typusFrameworkPackageId, "::vault::transfer_deposit_receipt"),
-            arguments: [input.tx.object(result[1]), input.tx.pure(input.user)],
-        });
-    }
     return input.tx;
 }
-exports.getHarvestTx = getHarvestTx;
+exports.getReduceFundTx = getReduceFundTx;
 /**
-    public fun redeem<D_TOKEN, B_TOKEN, I_TOKEN>(
+    public fun public_refresh_deposit_snapshot<D_TOKEN, B_TOKEN>(
+        typus_ecosystem_version: &TypusEcosystemVersion,
+        typus_user_registry: &mut TypusUserRegistry,
+        typus_leaderboard_registry: &mut TypusLeaderboardRegistry,
         registry: &mut Registry,
         index: u64,
         receipts: vector<TypusDepositReceipt>,
+        clock: &Clock,
         ctx: &mut TxContext,
-    )
-*/
-function getRedeemTx(input) {
+    ): (TypusDepositReceipt, vector<u64>) {
+ */
+function getRefreshDepositSnapshotTx(input) {
     var result = input.tx.moveCall({
-        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::redeem"),
+        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::public_refresh_deposit_snapshot"),
         typeArguments: input.typeArguments,
         arguments: [
+            input.tx.object(input.typusEcosystemVersion),
+            input.tx.object(input.typusUserRegistry),
+            input.tx.object(input.typusLeaderboardRegistry),
             input.tx.object(input.typusDovSingleRegistry),
             input.tx.pure(input.index),
             input.tx.makeMoveVec({
                 type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
                 objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
             }),
+            input.tx.object(constants_1.CLOCK),
         ],
     });
-    input.tx.moveCall({
-        target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
-        typeArguments: [input.typeArguments[2]],
-        arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
-    });
-    input.tx.moveCall({
-        target: "".concat(input.typusFrameworkPackageId, "::vault::transfer_deposit_receipt"),
-        arguments: [input.tx.object(result[1]), input.tx.pure(input.user)],
-    });
-    return input.tx;
-}
-exports.getRedeemTx = getRedeemTx;
-function getWithdrawHarvestClaimTx(input) {
-    var result = input.withdraw
-        ? input.tx.moveCall({
-            target: "".concat(input.typusDovSinglePackageId, "::tails_staking::withdraw"),
-            typeArguments: input.typeArguments,
-            arguments: [
-                input.tx.object(input.typusDovSingleRegistry),
-                input.tx.pure(input.index),
-                input.tx.makeMoveVec({
-                    type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
-                    objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
-                }),
-                input.tx.pure([]),
-                input.tx.pure(constants_1.CLOCK),
-            ],
-        })
-        : undefined;
-    if (input.withdraw) {
-        input.tx.moveCall({
-            target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
-            typeArguments: [input.typeArguments[0]],
-            arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
-        });
-    }
-    result = input.harvest
-        ? input.tx.moveCall({
-            target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::harvest"),
-            typeArguments: input.typeArguments,
-            arguments: [
-                input.tx.object(input.typusDovSingleRegistry),
-                input.tx.pure(input.index),
-                input.tx.makeMoveVec({
-                    type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
-                    objects: result
-                        ? [
-                            input.tx.object(input.tx.moveCall({
-                                target: "0x1::option::destroy_some",
-                                typeArguments: ["".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt")],
-                                arguments: [input.tx.object(result[1])],
-                            })),
-                        ]
-                        : input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
-                }),
-            ],
-        })
-        : result;
-    if (input.harvest) {
-        input.tx.moveCall({
-            target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
-            typeArguments: [input.typeArguments[1]],
-            arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
-        });
-    }
-    result = input.claim
-        ? input.tx.moveCall({
-            target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::claim"),
-            typeArguments: input.typeArguments,
-            arguments: [
-                input.tx.object(input.typusDovSingleRegistry),
-                input.tx.pure(input.index),
-                input.tx.makeMoveVec({
-                    type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
-                    objects: result
-                        ? [
-                            input.tx.object(input.tx.moveCall({
-                                target: "0x1::option::destroy_some",
-                                typeArguments: ["".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt")],
-                                arguments: [input.tx.object(result[1])],
-                            })),
-                        ]
-                        : input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
-                }),
-            ],
-        })
-        : result;
-    if (input.claim) {
-        input.tx.moveCall({
-            target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
-            typeArguments: [input.typeArguments[0]],
-            arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
-        });
-    }
-    if (input.incentiveToken) {
-        input.typeArguments.push(input.incentiveToken);
-        var receipts = result
-            ? [
-                input.tx.object(input.tx.moveCall({
-                    target: "0x1::option::destroy_some",
-                    typeArguments: ["".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt")],
-                    arguments: [input.tx.object(result[1])],
-                })),
-            ]
-            : input.receipts.map(function (receipt) { return input.tx.object(receipt); });
-        input.tx = getRedeemTx({
-            tx: input.tx,
-            typusFrameworkOriginPackageId: input.typusFrameworkOriginPackageId,
-            typusFrameworkPackageId: input.typusFrameworkPackageId,
-            typusDovSinglePackageId: input.typusDovSinglePackageId,
-            typusDovSingleRegistry: input.typusDovSingleRegistry,
-            typeArguments: input.typeArguments,
-            index: input.index,
-            receipts: receipts,
-            user: input.user,
-        });
-    }
-    else {
-        input.tx.moveCall({
-            target: "".concat(input.typusFrameworkPackageId, "::vault::transfer_deposit_receipt"),
-            arguments: [input.tx.object(result[1]), input.tx.pure(input.user)],
-        });
-    }
+    input.tx.transferObjects([input.tx.object(result[0])], input.user);
     return input.tx;
 }
-exports.getWithdrawHarvestClaimTx = getWithdrawHarvestClaimTx;
+exports.getRefreshDepositSnapshotTx = getRefreshDepositSnapshotTx;
 /**
     public(friend) entry fun new_bid<D_TOKEN, B_TOKEN>(
         registry: &mut Registry,
@@ -442,21 +194,25 @@ function getNewBidTx(input) {
             input.typeArguments[1] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI")) {
         var _a = __read(input.tx.splitCoins(input.tx.gas, [input.tx.pure(input.premium_required)]), 1), coin = _a[0];
         var result = input.tx.moveCall({
-            target: "".concat(input.typusDovSinglePackageId, "::tails_staking::new_bid_v2"),
+            target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::public_bid"),
             typeArguments: input.typeArguments,
             arguments: [
+                input.tx.object(input.typusEcosystemVersion),
+                input.tx.object(input.typusUserRegistry),
+                input.tx.object(input.tgldRegistry),
+                input.tx.object(input.typusLeaderboardRegistry),
                 input.tx.object(input.typusDovSingleRegistry),
                 input.tx.pure(input.index),
                 input.tx.makeMoveVec({ objects: [coin] }),
                 input.tx.pure(input.size),
-                input.tx.pure("0x6"),
+                input.tx.object(constants_1.CLOCK),
             ],
         });
         input.tx.transferObjects([input.tx.object(result[0])], input.user);
         input.tx.moveCall({
             target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_coins"),
             typeArguments: [input.typeArguments[1]],
-            arguments: [input.tx.object(result[1]), input.tx.pure(input.user)],
+            arguments: [input.tx.makeMoveVec({ objects: [input.tx.object(result[1])] }), input.tx.pure(input.user)],
         });
     }
     else {
@@ -474,9 +230,13 @@ function getNewBidTx(input) {
             arguments: [input.tx.object(balance)],
         });
         var result = input.tx.moveCall({
-            target: "".concat(input.typusDovSinglePackageId, "::tails_staking::new_bid_v2"),
+            target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::public_bid"),
             typeArguments: input.typeArguments,
             arguments: [
+                input.tx.object(input.typusEcosystemVersion),
+                input.tx.object(input.typusUserRegistry),
+                input.tx.object(input.tgldRegistry),
+                input.tx.object(input.typusLeaderboardRegistry),
                 input.tx.object(input.typusDovSingleRegistry),
                 input.tx.pure(input.index),
                 input.tx.makeMoveVec({ objects: [coin] }),
@@ -488,7 +248,7 @@ function getNewBidTx(input) {
         input.tx.moveCall({
             target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_coins"),
             typeArguments: [input.typeArguments[1]],
-            arguments: [input.tx.object(result[1]), input.tx.pure(input.user)],
+            arguments: [input.tx.makeMoveVec({ objects: [input.tx.object(result[1])] }), input.tx.pure(input.user)],
         });
     }
     return input.tx;
@@ -613,3 +373,49 @@ function getRebateTx(input) {
     return input.tx;
 }
 exports.getRebateTx = getRebateTx;
+function getCompoundWithRedeemTx(input) {
+    var raiseBalance = input.tx.moveCall({
+        target: "0x2::balance::zero",
+        typeArguments: [input.typeArguments[0]],
+        arguments: [],
+    });
+    var result = input.tx.moveCall({
+        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::public_raise_fund"),
+        typeArguments: [input.typeArguments[0], input.typeArguments[1]],
+        arguments: [
+            input.tx.object(input.typusEcosystemVersion),
+            input.tx.object(input.typusUserRegistry),
+            input.tx.object(input.typusLeaderboardRegistry),
+            input.tx.object(input.typusDovSingleRegistry),
+            input.tx.pure(input.index),
+            input.tx.makeMoveVec({
+                type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
+                objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
+            }),
+            input.tx.object(raiseBalance),
+            input.tx.pure(true),
+            input.tx.pure(false),
+            input.tx.object(constants_1.CLOCK),
+        ],
+    });
+    return getReduceFundTx({
+        tx: input.tx,
+        typusEcosystemVersion: input.typusEcosystemVersion,
+        typusUserRegistry: input.typusUserRegistry,
+        typusLeaderboardRegistry: input.typusLeaderboardRegistry,
+        typusFrameworkOriginPackageId: input.typusFrameworkOriginPackageId,
+        typusFrameworkPackageId: input.typusFrameworkPackageId,
+        typusDovSinglePackageId: input.typusDovSinglePackageId,
+        typusDovSingleRegistry: input.typusDovSingleRegistry,
+        typeArguments: input.typeArguments,
+        index: input.index,
+        receipts: [result[0]],
+        reduceFromWarmup: "0",
+        reduceFromActive: "0",
+        reduceFromPremium: false,
+        reduceFromInactive: false,
+        reduceFromIncentive: true,
+        user: input.user,
+    });
+}
+exports.getCompoundWithRedeemTx = getCompoundWithRedeemTx;

package/lib/utils/typus-dov-single-v2/user-history.d.ts

@@ -1,9 +1,6 @@
-import { SuiClient, SuiEvent } from "@mysten/sui.js/client";
+import { EventId, SuiClient, SuiEvent } from "@mysten/sui.js/client";
 import { Vault } from "./view-function";
-export declare function getUserHistory(provider: SuiClient, originPackage: string, vaults: {
-    [key: string]: Vault;
-}, sender: string, startTimeMs: number): Promise<TxHistory[]>;
-export declare function getUserEvents(provider: SuiClient, sender: string, startTimeMs: number): Promise<SuiEvent[]>;
+export declare function getUserEvents(provider: SuiClient, sender: string, cursor?: EventId | null): Promise<[SuiEvent[], EventId | null | undefined]>;
 export declare function getAutoBidEvents(provider: SuiClient, originPackage: string, startTimeMs: number): Promise<SuiEvent[]>;
 export interface TxHistory {
     Index: string | undefined;
@@ -17,4 +14,13 @@ export interface TxHistory {
     Date: Date;
     txDigest: string;
 }
+export declare function parseTxHistory(datas: Array<any>, originPackage: string, vaults: {
+    [key: string]: Vault;
+}): Promise<Array<TxHistory>>;
 export declare function getFromSentio(event: string, userAddress: string, startTimestamp: string): Promise<any[]>;
+export declare function getNewBidFromSentio(vaults: {
+    [key: string]: Vault;
+}, userAddress: string, startTimestamp: number): Promise<any>;
+export declare function getExerciseFromSentio(vaults: {
+    [key: string]: Vault;
+}, userAddress: string, startTimestamp: number): Promise<any>;