@typus/typus-sdk 1.2.82-dapp-kit → 1.2.83-tails-exp

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

@@ -16,416 +16,121 @@ 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.getRebateTx = exports.getMultiTransferBidReceiptTx = exports.getTransferBidReceiptTx = exports.getExerciseTx = exports.getNewBidTx = 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,
-            arguments: [
-                input.tx.object(input.typusDovSingleRegistry),
-                input.tx.pure(input.index),
-                input.tx.makeMoveVec({ objects: [coin] }),
-                input.tx.pure(input.amount),
-                input.tx.makeMoveVec({
-                    type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
-                    objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
-                }),
-                input.tx.pure(constants_1.CLOCK),
-            ],
-        });
-        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);
-    }
-    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.makeMoveVec({
-                    type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
-                    objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
-                }),
-                input.tx.pure(constants_1.CLOCK),
-            ],
-        });
-        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,
+    ): (TypusDepositReceipt, vector<u64>) {
+ */
+function getRaiseFundTx(input) {
+    var raiseBalance = 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.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,
             }),
-            input.tx.pure(input.share ? [input.share] : []),
-            input.tx.pure(constants_1.CLOCK),
+            input.tx.pure(input.raiseAmount),
         ],
     });
-    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.object(raiseBalance),
+            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);
     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) {
-    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 (receipt) { return input.tx.object(receipt); }),
-            }),
-            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) {
+    ): (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, "::tds_user_entry::claim"),
+        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.pure(constants_1.CLOCK),
         ],
     });
     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)],
-    });
-    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;
-/**
-    public fun redeem<D_TOKEN, B_TOKEN, I_TOKEN>(
-        registry: &mut Registry,
-        index: u64,
-        receipts: vector<TypusDepositReceipt>,
-        ctx: &mut TxContext,
-    )
-*/
-function getRedeemTx(input) {
-    var result = input.tx.moveCall({
-        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::redeem"),
-        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); }),
-            }),
-        ],
+        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[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)],
+        arguments: [input.tx.object(result[3]), 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)],
-        });
-    }
-    return input.tx;
-}
-exports.getWithdrawHarvestClaimTx = getWithdrawHarvestClaimTx;
+exports.getReduceFundTx = getReduceFundTx;
 /**
     public(friend) entry fun new_bid<D_TOKEN, B_TOKEN>(
         registry: &mut Registry,
@@ -442,7 +147,7 @@ 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::bid"),
+            target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::public_bid"),
             typeArguments: input.typeArguments,
             arguments: [
                 input.tx.object(input.typusEcosystemVersion),
@@ -453,7 +158,7 @@ function getNewBidTx(input) {
                 input.tx.pure(input.index),
                 input.tx.makeMoveVec({ objects: [coin] }),
                 input.tx.pure(input.size),
-                input.tx.pure("0x6"),
+                input.tx.pure(constants_1.CLOCK),
             ],
         });
         input.tx.transferObjects([input.tx.object(result[0])], input.user);
@@ -478,7 +183,7 @@ function getNewBidTx(input) {
             arguments: [input.tx.object(balance)],
         });
         var result = input.tx.moveCall({
-            target: "".concat(input.typusDovSinglePackageId, "::tails_staking::bid"),
+            target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::public_bid"),
             typeArguments: input.typeArguments,
             arguments: [
                 input.tx.object(input.typusEcosystemVersion),

package/lib/utils/user/view-functions.d.ts

@@ -1,6 +1,6 @@
 import { SuiClient } from "@mysten/sui.js/client";
 export declare const SENDER = "0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
-export declare function getAirdrop(input: {
+export declare function getUserMetadata(input: {
     provider: SuiClient;
     typusPackageId: string;
     typusEcosystemVersion: string;

package/lib/utils/user/view-functions.js

@@ -36,11 +36,11 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAirdrop = exports.SENDER = void 0;
+exports.getUserMetadata = exports.SENDER = void 0;
 var transactions_1 = require("@mysten/sui.js/transactions");
 var bcs_1 = require("@mysten/bcs");
 exports.SENDER = "0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
-function getAirdrop(input) {
+function getUserMetadata(input) {
     return __awaiter(this, void 0, void 0, function () {
         var transactionBlock, results, bytes, reader;
         return __generator(this, function (_a) {
@@ -68,4 +68,4 @@ function getAirdrop(input) {
         });
     });
 }
-exports.getAirdrop = getAirdrop;
+exports.getUserMetadata = getUserMetadata;

package/package.json

@@ -2,11 +2,11 @@
     "name": "@typus/typus-sdk",
     "author": "Typus",
     "description": "typus sdk",
-    "version": "1.2.82-dapp-kit",
+    "version": "1.2.83-tails-exp",
     "dependencies": {
         "@mysten/bcs": "^0.11.1",
-        "@mysten/kiosk": "0.8.10",
-        "@mysten/sui.js": "0.54.1",
+        "@mysten/kiosk": "0.7.12",
+        "@mysten/sui.js": "0.48.0",
         "@types/node": "^20.5.7",
         "aftermath-ts-sdk": "^1.1.14",
         "bignumber.js": "^9.1.1",
@@ -33,13 +33,12 @@
         "js-tokens": "^8.0.1",
         "js-yaml": "^4.1.0",
         "json2csv": "^6.0.0-alpha.2",
-        "lodash": "^4.17.21",
         "math-erf": "^1.0.0",
         "minimatch": "^9.0.3",
         "minimist": "^1.2.5",
         "mkdirp": "^3.0.1",
         "mocha": "^10.1.0",
-        "moment": "^2.30.1",
+        "moment": "^2.29.4",
         "node-cron": "^3.0.2",
         "once": "^1.4.0",
         "path-is-absolute": "^2.0.0",

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

@@ -1,78 +0,0 @@
-import BigNumber from "bignumber.js";
-import { SuiClient } from "@mysten/sui.js/dist/cjs/client";
-import { Auction, BidShare, Vault } from "../view-function";
-export declare const tokenOrder: {
-    [key: string]: number;
-};
-export declare const optionTypeOrder: {
-    [key: string]: number;
-};
-export declare const periodOrder: {
-    [key: string]: number;
-};
-export type Receipt = {
-    id: string;
-    index: string;
-    name: string;
-    description: string;
-    vid: string;
-};
-export type TokenAmount = {
-    value: string;
-    token: string;
-};
-export type BidVaultInfo = {
-    vaultInfo: Vault;
-    receipt: Receipt;
-};
-export interface Bid {
-    vaultIndex: string;
-    expiry: string;
-    auctionName: string;
-    strikes: string[];
-    bidSize: TokenAmount;
-    breakEvenPrice: string;
-    estPnls: TokenAmount[];
-    receiptsId: string[];
-    receiptsVid: string[];
-    settlePrice: string;
-    isAutoBid: boolean;
-}
-export interface OrderBy {
-    tokenOrder: number;
-    optionTypeOrder: number;
-    periodOrder: number;
-}
-export declare const IncentiveRateBp = 4;
-export declare const calcIncentiveRate: (incentiveBp: any) => number;
-export declare const calcDeliveryPrice: (bidShare: BidShare, vaultInfo: Vault) => BigNumber;
-export declare const calcBreakEvenPrice: (optionType: string, period: string, strikes: string[], bToken: string, price: string, incentive: number) => number;
-export declare const calcEstPnl: (live: boolean, incentive: number, bidSize: string, optionType: string, assets: string[], strikes: string[], bidShare: BidShare, deliveryPrice: string, oTokenPrice: string) => TokenAmount[];
-export declare const parseStrikes: (period: string, optionType: string, metadata: string) => string[];
-export declare const parseBidReceipt: (vaults: Vault[], bidReceipts: {
-    [key: string]: Receipt[];
-}) => {
-    sortedBidReceipts: string[];
-    bidVaultsInfo: BidVaultInfo[];
-};
-export declare const parseBid: (bidVaultInfo: BidVaultInfo, bidShare: BidShare, auction: Auction | null, oTokenPrice: string, isAutoBid: boolean) => Bid & OrderBy;
-export declare const getUserBidReceipts: (provider: SuiClient, network: string, originFramworkAddress: string, userAddress: string) => Promise<{
-    [key: string]: Receipt[];
-}>;
-/**
- * Fetch user's bids info
- *
- * @param provider - Sui Client instance.
- * @param network - network type in lowercase.
- * @param packageAddress - Typus main package address.
- * @param framworkAddress - Typus framwork package address.
- * @param originFramworkAddress - Typus intial framwork package address.
- * @param registryAddress - Typus registry package address.
- * @param strategyPoolAddress - strategy pool package address.
- * @param userAddress - user's wallet address.
- * @param prices - tokens prices (usd pair on Pyth)
- * @return User Bids.
- */
-export declare const fetchUserBids: (provider: SuiClient, network: string, packageAddress: string, framworkAddress: string, originFramworkAddress: string, registryAddress: string, strategyPoolAddress: string, userAddress: string, prices: {
-    [key: string]: string;
-}) => Promise<any>;