@typus/typus-sdk 1.2.85-tails-exp → 1.2.85

package/lib/utils/typus-dov-single-v2/function/token.d.ts

@@ -0,0 +1,21 @@
+export declare const WrappedToken: {
+    [key: string]: string;
+};
+export declare const UnwrappedToken: {
+    [key: string]: string;
+};
+export declare const MillionToken: {
+    [key: string]: string;
+};
+export declare const RemoveMillionToken: {
+    [key: string]: string;
+};
+export declare const LST: {
+    [key: string]: string;
+};
+export declare const StableCoin: string[];
+export declare const getTokenName: ({ token, wrapped, million }: {
+    token: string;
+    wrapped?: boolean | undefined;
+    million?: boolean | undefined;
+}) => string;

package/lib/utils/typus-dov-single-v2/function/token.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTokenName = exports.StableCoin = exports.LST = exports.RemoveMillionToken = exports.MillionToken = exports.UnwrappedToken = exports.WrappedToken = void 0;
+exports.WrappedToken = {
+    ETH: "WETH",
+    BTC: "WBTC",
+    SOL: "WSOL",
+};
+exports.UnwrappedToken = {
+    WETH: "ETH",
+    WBTC: "BTC",
+    WSOL: "SOL",
+};
+exports.MillionToken = {
+    FUD: "MFUD",
+};
+exports.RemoveMillionToken = {
+    MFUD: "FUD",
+};
+exports.LST = {
+    AFSUI: "SUI",
+};
+exports.StableCoin = ["USDC", "USDT", "BUCK", "USDY"];
+var getTokenName = function (_a) {
+    var _b, _c, _d, _e;
+    var token = _a.token, wrapped = _a.wrapped, million = _a.million;
+    var tokenName = token;
+    if (wrapped) {
+        tokenName = (_b = exports.WrappedToken[token]) !== null && _b !== void 0 ? _b : token;
+    }
+    else {
+        tokenName = (_c = exports.UnwrappedToken[token]) !== null && _c !== void 0 ? _c : token;
+    }
+    return million ? (_d = exports.MillionToken[tokenName]) !== null && _d !== void 0 ? _d : tokenName : (_e = exports.RemoveMillionToken[tokenName]) !== null && _e !== void 0 ? _e : tokenName;
+};
+exports.getTokenName = getTokenName;

package/lib/utils/typus-dov-single-v2/function/vault.d.ts

@@ -0,0 +1,8 @@
+import { Info } from "../view-function";
+export declare const Period: {
+    [key: number]: string;
+};
+export declare const AbbrStrategyName: {
+    [key: string]: string;
+};
+export declare const parseAssets: (info: Info) => string[];

package/lib/utils/typus-dov-single-v2/function/vault.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAssets = exports.AbbrStrategyName = exports.Period = void 0;
+var token_1 = require("../../token");
+exports.Period = {
+    0: "daily",
+    1: "weekly",
+    2: "monthly",
+    3: "hourly",
+};
+exports.AbbrStrategyName = {
+    0: "Call",
+    1: "Put",
+    2: "Call Spread",
+    4: "Capped Call",
+    5: "Capped Put",
+    6: "Capped Call",
+};
+var parseAssets = function (info) {
+    var dToken = info.depositToken, bToken = info.bidToken, oToken = info.settlementBase;
+    return (0, token_1.typeArgsToAssets)([dToken, bToken, oToken]);
+};
+exports.parseAssets = parseAssets;

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

@@ -1,63 +1,96 @@
 import { TransactionBlock, TransactionObjectArgument } from "@mysten/sui.js/transactions";
-export declare function getRaiseFundTx(input: {
+export declare function getDepositTx(input: {
+    tx: TransactionBlock;
+    typusFrameworkOriginPackageId: string;
+    typusDovSinglePackageId: string;
+    typusDovSingleRegistry: string;
+    mfudPackageId: string;
+    mfudRegistry: string;
+    mfudAmount: string;
+    typeArguments: string[];
+    index: string;
+    receipts: string[] | TransactionObjectArgument[];
+    user: string;
+    coins: string[];
+}): TransactionBlock;
+export declare function getWithdrawTx(input: {
     tx: TransactionBlock;
-    typusEcosystemVersion: string;
-    typusUserRegistry: string;
-    typusLeaderboardRegistry: string;
     typusFrameworkOriginPackageId: string;
     typusFrameworkPackageId: string;
     typusDovSinglePackageId: string;
     typusDovSingleRegistry: string;
-    typusTokenPackageId: string;
-    typusTokenRegistry: string;
-    typusTokenType: string;
+    mfudPackageId: string;
+    mfudRegistry: string;
     typeArguments: string[];
     index: string;
     receipts: string[] | TransactionObjectArgument[];
-    raiseCoins: string[];
-    raiseAmount: string;
-    raiseFromPremium: boolean;
-    raiseFromInactive: boolean;
     user: string;
+    amount?: string;
 }): TransactionBlock;
-export declare function getReduceFundTx(input: {
+export declare function getUnsubscribeTx(input: {
+    tx: TransactionBlock;
+    typusFrameworkOriginPackageId: string;
+    typusDovSinglePackageId: string;
+    typusDovSingleRegistry: string;
+    typeArguments: string[];
+    index: string;
+    receipts: string[] | TransactionObjectArgument[];
+    user: string;
+    amount?: string;
+}): TransactionBlock;
+export declare function getCompoundTx(input: {
+    tx: TransactionBlock;
+    typusFrameworkOriginPackageId: string;
+    typusFrameworkPackageId: string;
+    typusDovSinglePackageId: string;
+    typusDovSingleRegistry: string;
+    mfudPackageId: string;
+    mfudRegistry: string;
+    typeArguments: string[];
+    index: string;
+    receipts: string[] | TransactionObjectArgument[];
+    user: string;
+    incentiveToken?: string;
+}): TransactionBlock;
+export declare function getClaimTx(input: {
     tx: TransactionBlock;
-    typusEcosystemVersion: string;
-    typusUserRegistry: string;
-    typusLeaderboardRegistry: string;
     typusFrameworkOriginPackageId: string;
     typusFrameworkPackageId: string;
     typusDovSinglePackageId: string;
     typusDovSingleRegistry: string;
+    mfudPackageId: string;
+    mfudRegistry: string;
     typeArguments: string[];
-    typusTokenPackageId: string;
-    typusTokenRegistry: string;
-    typusTokenType: string;
     index: string;
     receipts: string[] | TransactionObjectArgument[];
-    reduceFromWarmup: string;
-    reduceFromActive: string;
-    reduceFromPremium: boolean;
-    reduceFromInactive: boolean;
-    reduceFromIncentive: boolean;
     user: string;
 }): TransactionBlock;
-export declare function getDepositTx(input: {
+export declare function getHarvestTx(input: {
     tx: TransactionBlock;
-    typusEcosystemVersion: string;
-    typusUserRegistry: string;
-    typusLeaderboardRegistry: string;
     typusFrameworkOriginPackageId: string;
+    typusFrameworkPackageId: string;
+    typusDovSinglePackageId: string;
+    typusDovSingleRegistry: string;
+    mfudPackageId: string;
+    mfudRegistry: string;
+    typeArguments: string[];
+    index: string;
+    receipts: string[] | TransactionObjectArgument[];
+    user: string;
+    incentiveToken?: string;
+}): TransactionBlock;
+export declare function getRedeemTx(input: {
+    tx: TransactionBlock;
+    typusFrameworkOriginPackageId: string;
+    typusFrameworkPackageId: string;
     typusDovSinglePackageId: string;
     typusDovSingleRegistry: string;
     mfudPackageId: string;
     mfudRegistry: string;
-    mfudAmount: string;
     typeArguments: string[];
     index: string;
     receipts: string[] | TransactionObjectArgument[];
     user: string;
-    coins: string[];
 }): TransactionBlock;
 export declare function getNewBidTx(input: {
     tx: TransactionBlock;

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

@@ -16,168 +16,288 @@ var __read = (this && this.__read) || function (o, n) {
     return ar;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getWithdrawProfitStrategyTx = exports.getCloseStrategyTx = exports.getUpdateStrategyTx = exports.getNewStrategyTx = exports.getRebateTx = exports.getExerciseTx = exports.getNewBidTx = exports.getDepositTx = exports.getReduceFundTx = exports.getRaiseFundTx = void 0;
+exports.getWithdrawProfitStrategyTx = exports.getCloseStrategyTx = exports.getUpdateStrategyTx = exports.getNewStrategyTx = exports.getRebateTx = exports.getExerciseTx = exports.getNewBidTx = exports.getRedeemTx = exports.getHarvestTx = exports.getClaimTx = exports.getCompoundTx = exports.getUnsubscribeTx = exports.getWithdrawTx = exports.getDepositTx = void 0;
 var transactions_1 = require("@mysten/sui.js/transactions");
 var constants_1 = require("../../constants");
-function getRaiseFundTx(input) {
-    var typusToken = input.tx.moveCall({
-        target: "".concat(input.typusTokenPackageId, "::").concat(input.typusTokenType.split("::")[1], "::mint"),
+var user_entry_1 = require("./user-entry");
+function getDepositTx(input) {
+    var mfud = input.tx.moveCall({
+        target: "".concat(input.mfudPackageId, "::mfud::mint"),
         arguments: [
-            input.tx.object(input.typusTokenPackageId),
-            input.tx.makeMoveVec({ objects: input.raiseCoins }),
-            input.tx.pure(input.raiseAmount),
+            input.tx.object(input.mfudRegistry),
+            input.tx.makeMoveVec({ objects: input.coins.map(function (id) { return input.tx.object(id); }) }),
+            input.tx.pure(input.mfudAmount),
         ],
     });
-    var typusTokenBalance = input.tx.moveCall({
-        target: "0x2::coin::into_balance",
-        typeArguments: [input.typusTokenType],
-        arguments: [input.tx.object(typusToken)],
-    });
     var result = input.tx.moveCall({
-        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::public_raise_fund"),
+        target: "".concat(input.typusDovSinglePackageId, "::tails_staking::deposit"),
         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({ objects: [mfud] }),
+            input.tx.pure(input.mfudAmount),
             input.tx.makeMoveVec({
                 type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
-                objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
+                objects: input.receipts.map(function (id) { return input.tx.object(id); }),
             }),
-            input.tx.object(typusTokenBalance),
-            input.tx.pure(input.raiseFromPremium),
-            input.tx.pure(input.raiseFromInactive),
             input.tx.pure(constants_1.CLOCK),
         ],
     });
-    input.tx.transferObjects([input.tx.object(result[0])], input.user);
+    input.tx.moveCall({
+        target: "0x1::vector::destroy_empty",
+        typeArguments: ["0x2::coin::Coin<" + input.typeArguments[0] + ">"],
+        arguments: [input.tx.object(result[0])],
+    });
+    input.tx.transferObjects([input.tx.object(result[1])], input.user);
     return input.tx;
 }
-exports.getRaiseFundTx = getRaiseFundTx;
-function getReduceFundTx(input) {
+exports.getDepositTx = getDepositTx;
+function getWithdrawTx(input) {
     var result = input.tx.moveCall({
-        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::public_reduce_fund"),
+        target: "".concat(input.typusDovSinglePackageId, "::tails_staking::withdraw"),
         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); }),
+                objects: input.receipts.map(function (id) { return input.tx.object(id); }),
             }),
-            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.pure(input.amount ? [input.amount] : []),
             input.tx.pure(constants_1.CLOCK),
         ],
     });
+    var mfud_coin = input.tx.moveCall({
+        target: "0x2::coin::from_balance",
+        typeArguments: [input.typeArguments[0]],
+        arguments: [input.tx.object(result[0])],
+    });
+    var fud_coin = input.tx.moveCall({
+        target: "".concat(input.mfudPackageId, "::mfud::burn"),
+        arguments: [input.tx.object(input.mfudRegistry), input.tx.object(mfud_coin)],
+    });
+    input.tx.transferObjects([input.tx.object(fud_coin)], input.user);
     input.tx.moveCall({
         target: "".concat(input.typusFrameworkPackageId, "::vault::transfer_deposit_receipt"),
-        arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
+        arguments: [input.tx.object(result[1]), input.tx.pure(input.user)],
     });
-    if (input.typeArguments[0] == input.typusTokenType) {
-        var typusToken = input.tx.moveCall({
-            target: "0x2::coin::from_balance",
-            typeArguments: [input.typeArguments[0]],
-            arguments: [input.tx.object(result[1])],
-        });
-        var token = input.tx.moveCall({
-            target: "".concat(input.typusTokenPackageId, "::").concat(input.typusTokenType.split("::")[1], "::burn"),
-            arguments: [input.tx.object(input.typusTokenRegistry), input.tx.object(typusToken)],
-        });
-        input.tx.transferObjects([input.tx.object(token)], input.user);
-    }
-    else {
-        input.tx.moveCall({
-            target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
-            typeArguments: [input.typeArguments[0]],
-            arguments: [input.tx.object(result[1]), input.tx.pure(input.user)],
-        });
-    }
-    if (input.typeArguments[1] == input.typusTokenType) {
-        var typusToken = input.tx.moveCall({
-            target: "0x2::coin::from_balance",
-            typeArguments: [input.typeArguments[1]],
-            arguments: [input.tx.object(result[2])],
-        });
-        var token = input.tx.moveCall({
-            target: "".concat(input.typusTokenPackageId, "::").concat(input.typusTokenType.split("::")[1], "::burn"),
-            arguments: [input.tx.object(input.typusTokenRegistry), input.tx.object(typusToken)],
-        });
-        input.tx.transferObjects([input.tx.object(token)], input.user);
+    return input.tx;
+}
+exports.getWithdrawTx = getWithdrawTx;
+function getUnsubscribeTx(input) {
+    var result = input.tx.moveCall({
+        target: "".concat(input.typusDovSinglePackageId, "::tails_staking::unsubscribe"),
+        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 (id) { return input.tx.object(id); }),
+            }),
+            input.tx.pure(input.amount ? [input.amount] : []),
+            input.tx.pure(constants_1.CLOCK),
+        ],
+    });
+    input.tx.transferObjects([input.tx.object(result[0])], input.user);
+    return input.tx;
+}
+exports.getUnsubscribeTx = getUnsubscribeTx;
+function getCompoundTx(input) {
+    var result = input.tx.moveCall({
+        target: "".concat(input.typusDovSinglePackageId, "::tails_staking::compound"),
+        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 (id) { return input.tx.object(id); }),
+            }),
+            input.tx.object(constants_1.CLOCK),
+        ],
+    });
+    if (input.incentiveToken) {
+        input.typeArguments.push(input.incentiveToken);
+        if (input.incentiveToken == "".concat(input.mfudPackageId, "::mfud::MFUD")) {
+            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,
+                mfudPackageId: input.mfudPackageId,
+                mfudRegistry: input.mfudRegistry,
+                typeArguments: input.typeArguments,
+                index: input.index,
+                receipts: [input.tx.object(receipt)],
+                user: input.user,
+            });
+        }
+        else {
+            var receipt = input.tx.moveCall({
+                target: "0x1::option::destroy_some",
+                typeArguments: ["".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt")],
+                arguments: [input.tx.object(result[1])],
+            });
+            input.tx = (0, user_entry_1.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, "::utils::transfer_balance"),
-            typeArguments: [input.typeArguments[1]],
-            arguments: [input.tx.object(result[2]), input.tx.pure(input.user)],
-        });
+        input.tx.transferObjects([input.tx.object(result[0])], input.user);
     }
-    if (input.typeArguments[2] == input.typusTokenType) {
-        var typusToken = input.tx.moveCall({
-            target: "0x2::coin::from_balance",
-            typeArguments: [input.typeArguments[2]],
-            arguments: [input.tx.object(result[3])],
-        });
-        var token = input.tx.moveCall({
-            target: "".concat(input.typusTokenPackageId, "::").concat(input.typusTokenType.split("::")[1], "::burn"),
-            arguments: [input.tx.object(input.typusTokenRegistry), input.tx.object(typusToken)],
-        });
-        input.tx.transferObjects([input.tx.object(token)], input.user);
+    return input.tx;
+}
+exports.getCompoundTx = getCompoundTx;
+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 (id) { return input.tx.object(id); }),
+            }),
+        ],
+    });
+    var mfud_coin = input.tx.moveCall({
+        target: "0x2::coin::from_balance",
+        typeArguments: [input.typeArguments[0]],
+        arguments: [input.tx.object(result[0])],
+    });
+    var fud_coin = input.tx.moveCall({
+        target: "".concat(input.mfudPackageId, "::mfud::burn"),
+        arguments: [input.tx.object(input.mfudRegistry), input.tx.object(mfud_coin)],
+    });
+    input.tx.transferObjects([input.tx.object(fud_coin)], 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.getClaimTx = getClaimTx;
+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 (id) { return input.tx.object(id); }),
+            }),
+        ],
+    });
+    var mfud_coin = input.tx.moveCall({
+        target: "0x2::coin::from_balance",
+        typeArguments: [input.typeArguments[1]],
+        arguments: [input.tx.object(result[0])],
+    });
+    var fud_coin = input.tx.moveCall({
+        target: "".concat(input.mfudPackageId, "::mfud::burn"),
+        arguments: [input.tx.object(input.mfudRegistry), input.tx.object(mfud_coin)],
+    });
+    input.tx.transferObjects([input.tx.object(fud_coin)], input.user);
+    if (input.incentiveToken) {
+        input.typeArguments.push(input.incentiveToken);
+        if (input.incentiveToken == "".concat(input.mfudPackageId, "::mfud::MFUD")) {
+            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,
+                mfudPackageId: input.mfudPackageId,
+                mfudRegistry: input.mfudRegistry,
+                typeArguments: input.typeArguments,
+                index: input.index,
+                receipts: [input.tx.object(receipt)],
+                user: input.user,
+            });
+        }
+        else {
+            var receipt = input.tx.moveCall({
+                target: "0x1::option::destroy_some",
+                typeArguments: ["".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt")],
+                arguments: [input.tx.object(result[1])],
+            });
+            input.tx = (0, user_entry_1.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, "::utils::transfer_balance"),
-            typeArguments: [input.typeArguments[2]],
-            arguments: [input.tx.object(result[3]), input.tx.pure(input.user)],
+            target: "".concat(input.typusFrameworkPackageId, "::vault::transfer_deposit_receipt"),
+            arguments: [input.tx.object(result[1]), input.tx.pure(input.user)],
         });
     }
     return input.tx;
 }
-exports.getReduceFundTx = getReduceFundTx;
-function getDepositTx(input) {
-    var mfud = input.tx.moveCall({
-        target: "".concat(input.mfudPackageId, "::mfud::mint"),
-        arguments: [
-            input.tx.object(input.mfudRegistry),
-            input.tx.makeMoveVec({ objects: input.coins.map(function (id) { return input.tx.object(id); }) }),
-            input.tx.pure(input.mfudAmount),
-        ],
-    });
+exports.getHarvestTx = getHarvestTx;
+function getRedeemTx(input) {
     var result = input.tx.moveCall({
-        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::public_deposit"),
+        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::redeem"),
         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({ objects: [mfud] }),
-            input.tx.pure(input.mfudAmount),
             input.tx.makeMoveVec({
                 type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
                 objects: input.receipts.map(function (id) { return input.tx.object(id); }),
             }),
-            input.tx.pure(constants_1.CLOCK),
         ],
     });
-    input.tx.moveCall({
-        target: "0x1::vector::destroy_empty",
-        typeArguments: ["0x2::coin::Coin<" + input.typeArguments[0] + ">"],
+    var mfud_coin = input.tx.moveCall({
+        target: "0x2::coin::from_balance",
+        typeArguments: [input.typeArguments[2]],
         arguments: [input.tx.object(result[0])],
     });
-    input.tx.transferObjects([input.tx.object(result[1])], input.user);
+    var fud_coin = input.tx.moveCall({
+        target: "".concat(input.mfudPackageId, "::mfud::burn"),
+        arguments: [input.tx.object(input.mfudRegistry), input.tx.object(mfud_coin)],
+    });
+    input.tx.transferObjects([input.tx.object(fud_coin)], 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.getDepositTx = getDepositTx;
+exports.getRedeemTx = getRedeemTx;
 function getNewBidTx(input) {
     var mfud = input.tx.moveCall({
         target: "".concat(input.mfudPackageId, "::mfud::mint"),
@@ -188,7 +308,7 @@ function getNewBidTx(input) {
         ],
     });
     var result = input.tx.moveCall({
-        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::public_bid"),
+        target: "".concat(input.typusDovSinglePackageId, "::tails_staking::bid"),
         typeArguments: input.typeArguments,
         arguments: [
             input.tx.object(input.typusEcosystemVersion),