@typus/typus-sdk 1.2.66-tgld → 1.2.67

package/lib/utils/typus-dov-single/db-data.js

@@ -0,0 +1,226 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getShowMap = exports.getDb = void 0;
+var apiUrl = "https://us-central1-aqueous-freedom-378103.cloudfunctions.net/mongodb";
+function getDb(database_1, functionNames_1, vaultIndex_1, startTsMs_1, limit_1) {
+    return __awaiter(this, arguments, void 0, function (database, functionNames, vaultIndex, startTsMs, limit, endTsMs) {
+        var jsonData, response, data;
+        if (endTsMs === void 0) { endTsMs = undefined; }
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    jsonData = JSON.stringify({
+                        database: database,
+                        functionNames: functionNames,
+                        vaultIndex: vaultIndex,
+                        startTsMs: startTsMs,
+                        endTsMs: endTsMs,
+                        limit: limit,
+                    });
+                    return [4 /*yield*/, fetch(apiUrl, {
+                            method: "POST",
+                            headers: { "Content-Type": "application/json" },
+                            body: jsonData,
+                        })];
+                case 1:
+                    response = _a.sent();
+                    if (!response.ok) return [3 /*break*/, 3];
+                    return [4 /*yield*/, response.json()];
+                case 2:
+                    data = _a.sent();
+                    return [2 /*return*/, data];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.getDb = getDb;
+function getShowMap(database_1, portfolioVaults_1) {
+    return __awaiter(this, arguments, void 0, function (database, portfolioVaults, vaultIndex, startTsMs, limit) {
+        var events, groupEventMap, showMap;
+        var _this = this;
+        if (vaultIndex === void 0) { vaultIndex = undefined; }
+        if (startTsMs === void 0) { startTsMs = "0"; }
+        if (limit === void 0) { limit = 1000; }
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, getDb(database, ["NewAuction", "Delivery", "Settle"], vaultIndex, startTsMs, limit)];
+                case 1:
+                    events = _a.sent();
+                    return [4 /*yield*/, events.reduce(function (promise, event) { return __awaiter(_this, void 0, void 0, function () {
+                            var map, index, round, round_event, round_events, round_events, round_events;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, promise];
+                                    case 1:
+                                        map = _a.sent();
+                                        index = event.index.toString();
+                                        round = event.round.toString();
+                                        round_event = {
+                                            newAuctionEvent: undefined,
+                                            deliveryEvent: undefined,
+                                            settleEvent: undefined,
+                                        };
+                                        if (map.has(index)) {
+                                            round_events = map.get(index);
+                                            if (round_events.has(round)) {
+                                                round_event = round_events.get(round);
+                                            }
+                                        }
+                                        switch (event.function) {
+                                            case "NewAuction":
+                                                round_event.newAuctionEvent = event;
+                                                round_event.newAuctionEvent.vault_config = {
+                                                    payoffConfigs: event.vault_config.payoff_configs.map(function (x) {
+                                                        return ({
+                                                            strikePct: x.strike_pct,
+                                                            weight: x.weight,
+                                                            isBuyer: x.is_buyer,
+                                                            strike: x.strike,
+                                                        });
+                                                    }),
+                                                    strikeIncrement: event.vault_config.strike_increment,
+                                                    decaySpeed: event.vault_config.decay_speed,
+                                                    initialPrice: event.vault_config.initial_price,
+                                                    finalPrice: event.vault_config.final_price,
+                                                    auctionDurationInMs: event.vault_config.auction_duration_in_ms,
+                                                };
+                                                break;
+                                            case "Delivery":
+                                                round_event.deliveryEvent = event;
+                                                break;
+                                            case "Settle":
+                                                round_event.settleEvent = event;
+                                                break;
+                                        }
+                                        if (map.get(index)) {
+                                            round_events = map.get(index);
+                                            round_events.set(round, round_event);
+                                            map.set(index, round_events);
+                                        }
+                                        else {
+                                            round_events = new Map();
+                                            round_events.set(round, round_event);
+                                            map.set(index, round_events);
+                                        }
+                                        return [2 /*return*/, map];
+                                }
+                            });
+                        }); }, Promise.resolve(new Map()))];
+                case 2:
+                    groupEventMap = _a.sent();
+                    showMap = new Map();
+                    return [4 /*yield*/, groupEventMap.forEach(function (innerMap, outerKey) { return __awaiter(_this, void 0, void 0, function () {
+                            var newInnerMap_1;
+                            var _this = this;
+                            return __generator(this, function (_a) {
+                                if (portfolioVaults[outerKey]) {
+                                    newInnerMap_1 = new Map();
+                                    innerMap.forEach(function (groupEvent, innerKey) { return __awaiter(_this, void 0, void 0, function () {
+                                        var show;
+                                        return __generator(this, function (_a) {
+                                            switch (_a.label) {
+                                                case 0: return [4 /*yield*/, groupEventToShow(groupEvent, portfolioVaults[outerKey])];
+                                                case 1:
+                                                    show = _a.sent();
+                                                    // console.log(show);
+                                                    newInnerMap_1.set(innerKey, show);
+                                                    return [2 /*return*/];
+                                            }
+                                        });
+                                    }); });
+                                    showMap.set(outerKey, newInnerMap_1);
+                                }
+                                return [2 /*return*/];
+                            });
+                        }); })];
+                case 3:
+                    _a.sent();
+                    // console.log(showMap);
+                    return [2 /*return*/, showMap];
+            }
+        });
+    });
+}
+exports.getShowMap = getShowMap;
+function groupEventToShow(groupEvent, portfolioVault) {
+    return __awaiter(this, void 0, void 0, function () {
+        var PaidToDepositors, portfolio_payoff, PaidToBidders, exp, ActivationTsMs, SettlementTsMs, result;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+        return __generator(this, function (_r) {
+            PaidToDepositors = Number((_a = groupEvent.deliveryEvent) === null || _a === void 0 ? void 0 : _a.premium_value) / Math.pow(10, Number(portfolioVault.config.bTokenDecimal));
+            portfolio_payoff = ((_b = groupEvent.settleEvent) === null || _b === void 0 ? void 0 : _b.portfolio_payoff_is_neg)
+                ? Number(-((_c = groupEvent.settleEvent) === null || _c === void 0 ? void 0 : _c.portfolio_payoff))
+                : Number((_d = groupEvent.settleEvent) === null || _d === void 0 ? void 0 : _d.portfolio_payoff);
+            PaidToBidders = portfolio_payoff / Math.pow(10, Number(portfolioVault.config.oTokenDecimal));
+            switch (portfolioVault.config.period) {
+                case 0:
+                    exp = 365;
+                    break;
+                case 1:
+                    exp = 52;
+                    break;
+                case 2:
+                    exp = 12;
+                    break;
+            }
+            ActivationTsMs = Number((_e = groupEvent.newAuctionEvent) === null || _e === void 0 ? void 0 : _e.timestamp_ms);
+            SettlementTsMs = Number((_f = groupEvent.settleEvent) === null || _f === void 0 ? void 0 : _f.timestamp_ms);
+            result = {
+                // newAuctionEvent
+                NewAuctionTx: (_g = groupEvent.newAuctionEvent) === null || _g === void 0 ? void 0 : _g.tx_digest,
+                ActivationDate: new Date(ActivationTsMs - (ActivationTsMs % 3600000)),
+                StrikePrice: (_h = groupEvent.newAuctionEvent) === null || _h === void 0 ? void 0 : _h.vault_config.payoffConfigs.map(function (payoffConfig) { return Number(payoffConfig.strike) / Math.pow(10, 8); }),
+                // deliveryEvent
+                DeliveryTx: (_j = groupEvent.deliveryEvent) === null || _j === void 0 ? void 0 : _j.tx_digest,
+                ProjectedAPY: Math.pow((1 + (1.01 * Number((_k = groupEvent.deliveryEvent) === null || _k === void 0 ? void 0 : _k.delivery_price)) / Math.pow(10, Number(portfolioVault.config.bTokenDecimal))), exp) - 1,
+                Filled: Number((_l = groupEvent.deliveryEvent) === null || _l === void 0 ? void 0 : _l.delivery_size) / Number((_m = groupEvent.deliveryEvent) === null || _m === void 0 ? void 0 : _m.max_size),
+                PaidToDepositors: PaidToDepositors,
+                // settleEvent
+                SettleTx: (_o = groupEvent.settleEvent) === null || _o === void 0 ? void 0 : _o.tx_digest,
+                SettlementTime: new Date(SettlementTsMs - (SettlementTsMs % 3600000)),
+                SettlePrice: Number((_p = groupEvent.settleEvent) === null || _p === void 0 ? void 0 : _p.oracle_price) / Math.pow(10, 8),
+                Return: Number((_q = groupEvent.settleEvent) === null || _q === void 0 ? void 0 : _q.share_price) / Math.pow(10, 8) - 1,
+                PaidToBidders: PaidToBidders,
+                EarnedByDepositors: PaidToDepositors - PaidToBidders,
+            };
+            return [2 /*return*/, result];
+        });
+    });
+}

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

@@ -0,0 +1,63 @@
+import { SuiClient } from "@mysten/sui.js/client";
+import { DepositVault, BidVault } from "../typus-framework/vault";
+import { Auction } from "../typus-framework/dutch";
+export interface PortfolioVault {
+    vaultId: string;
+    typeArgs: string[];
+    assets: string[];
+    info: Info;
+    config: Config;
+    depositVault: DepositVault;
+    bidVault: BidVault;
+    auction: Auction;
+    authority: string;
+    tokenTvl: bigint;
+    usdTvl: bigint;
+}
+export interface Info {
+    index: string;
+    creator: string;
+    createTsMs: string;
+    round: string;
+    deliveryInfo?: DeliveryInfo;
+}
+export interface DeliveryInfo {
+    round: string;
+    price: string;
+    size: string;
+    premium: string;
+    tsMs: string;
+}
+export interface Config {
+    optionType: string;
+    period: number;
+    activationTsMs: string;
+    expirationTsMs: string;
+    auctionDelayTsMs: string;
+    dTokenDecimal: string;
+    bTokenDecimal: string;
+    oTokenDecimal: string;
+    lotSize: string;
+    capacity: string;
+    leverage: string;
+    hasNext: boolean;
+    activeVaultConfig: VaultConfig;
+    warmupVaultConfig: VaultConfig;
+    upcomingVaultConfig: VaultConfig;
+}
+export interface VaultConfig {
+    payoffConfigs: PayoffConfig[];
+    strikeIncrement: string;
+    decaySpeed: string;
+    initialPrice: string;
+    finalPrice: string;
+    auctionDurationInMs: string;
+}
+export interface PayoffConfig {
+    strikePct: string;
+    weight: string;
+    isBuyer: boolean;
+    strike?: string;
+}
+export declare function getPortfolioVaults(provider: SuiClient, registry: string, deposit_vault_registry: string, bid_vault_registry: string, index?: string): Promise<Map<string, PortfolioVault>>;
+export declare function getPortfolioVaultAuctionDelayTsMs(provider: SuiClient, portfolio_vault: PortfolioVault): Promise<string>;

package/lib/utils/typus-dov-single/portfolio-vault.js

@@ -0,0 +1,284 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPortfolioVaultAuctionDelayTsMs = exports.getPortfolioVaults = void 0;
+var vault_1 = require("../typus-framework/vault");
+var dutch_1 = require("../typus-framework/dutch");
+var token_1 = require("../token");
+function getPortfolioVaults(provider, registry, deposit_vault_registry, bid_vault_registry, index) {
+    return __awaiter(this, void 0, void 0, function () {
+        var portfolioVaultIds, portfolioVaults, depositVaultIds, bidVaultIds;
+        var _this = this;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    console.warn = function () { };
+                    return [4 /*yield*/, provider.getDynamicFields({ parentId: registry })];
+                case 1:
+                    portfolioVaultIds = (_a.sent()).data
+                        .filter(function (x) { return (index ? x.name.value == index : true); })
+                        .map(function (x) { return x.objectId; });
+                    return [4 /*yield*/, provider.multiGetObjects({
+                            ids: portfolioVaultIds,
+                            options: { showContent: true },
+                        })];
+                case 2: return [4 /*yield*/, (_a.sent())
+                        .filter(function (portfolioVault) { return portfolioVault.error == undefined; })
+                        // @ts-ignore
+                        .filter(function (portfolioVault) { return portfolioVault.data.content.type.includes("PortfolioVault"); })
+                        .reduce(function (promise, portfolioVault) { return __awaiter(_this, void 0, void 0, function () {
+                        var map, vaultId, auctionDelayTsMs, typeArgs, assets, deliveryInfo, info, config, auction, authority;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, promise];
+                                case 1:
+                                    map = _a.sent();
+                                    vaultId = portfolioVault.data.content.fields.id.id;
+                                    auctionDelayTsMs = "0";
+                                    typeArgs = new RegExp(".*<(.*), (.*), (.*)>").exec(portfolioVault.data.content.type).slice(1, 4);
+                                    assets = (0, token_1.typeArgsToAssets)(typeArgs);
+                                    deliveryInfo = 
+                                    // @ts-ignore
+                                    portfolioVault.data.content.fields.info.fields.delivery_info
+                                        ? {
+                                            // @ts-ignore
+                                            round: portfolioVault.data.content.fields.info.fields.delivery_info.fields.round,
+                                            // @ts-ignore
+                                            price: portfolioVault.data.content.fields.info.fields.delivery_info.fields.price,
+                                            // @ts-ignore
+                                            size: portfolioVault.data.content.fields.info.fields.delivery_info.fields.size,
+                                            // @ts-ignore
+                                            premium: portfolioVault.data.content.fields.info.fields.delivery_info.fields.premium,
+                                            // @ts-ignore
+                                            tsMs: portfolioVault.data.content.fields.info.fields.delivery_info.fields.ts_ms,
+                                        }
+                                        : undefined;
+                                    info = {
+                                        // @ts-ignore
+                                        index: portfolioVault.data.content.fields.info.fields.index,
+                                        // @ts-ignore
+                                        creator: portfolioVault.data.content.fields.info.fields.creator,
+                                        // @ts-ignore
+                                        createTsMs: portfolioVault.data.content.fields.info.fields.create_ts_ms,
+                                        // @ts-ignore
+                                        round: portfolioVault.data.content.fields.info.fields.round,
+                                        deliveryInfo: deliveryInfo,
+                                    };
+                                    config = {
+                                        // @ts-ignore
+                                        optionType: portfolioVault.data.content.fields.config.fields.option_type,
+                                        // @ts-ignore
+                                        period: portfolioVault.data.content.fields.config.fields.period,
+                                        // @ts-ignore
+                                        activationTsMs: portfolioVault.data.content.fields.config.fields.activation_ts_ms,
+                                        // @ts-ignore
+                                        expirationTsMs: portfolioVault.data.content.fields.config.fields.expiration_ts_ms,
+                                        auctionDelayTsMs: auctionDelayTsMs,
+                                        // @ts-ignore
+                                        dTokenDecimal: portfolioVault.data.content.fields.config.fields.d_token_decimal,
+                                        // @ts-ignore
+                                        bTokenDecimal: portfolioVault.data.content.fields.config.fields.b_token_decimal,
+                                        // @ts-ignore
+                                        oTokenDecimal: portfolioVault.data.content.fields.config.fields.o_token_decimal,
+                                        // @ts-ignore
+                                        lotSize: portfolioVault.data.content.fields.config.fields.lot_size,
+                                        // @ts-ignore
+                                        capacity: portfolioVault.data.content.fields.config.fields.capacity,
+                                        // @ts-ignore
+                                        leverage: portfolioVault.data.content.fields.config.fields.leverage,
+                                        // @ts-ignore
+                                        hasNext: portfolioVault.data.content.fields.config.fields.has_next,
+                                        activeVaultConfig: {
+                                            // @ts-ignore
+                                            payoffConfigs: portfolioVault.data.content.fields.config.fields.active_vault_config.fields.payoff_configs.map(function (x) {
+                                                return ({
+                                                    strikePct: x.fields.strike_pct,
+                                                    weight: x.fields.weight,
+                                                    isBuyer: x.fields.is_buyer,
+                                                    strike: x.fields.strike,
+                                                });
+                                            }),
+                                            // @ts-ignore
+                                            strikeIncrement: portfolioVault.data.content.fields.config.fields.active_vault_config.fields.strike_increment,
+                                            // @ts-ignore
+                                            decaySpeed: portfolioVault.data.content.fields.config.fields.active_vault_config.fields.decay_speed,
+                                            // @ts-ignore
+                                            initialPrice: portfolioVault.data.content.fields.config.fields.active_vault_config.fields.initial_price,
+                                            // @ts-ignore
+                                            finalPrice: portfolioVault.data.content.fields.config.fields.active_vault_config.fields.final_price,
+                                            // @ts-ignore
+                                            auctionDurationInMs: portfolioVault.data.content.fields.config.fields.active_vault_config.fields.auction_duration_in_ms,
+                                        },
+                                        warmupVaultConfig: {
+                                            // @ts-ignore
+                                            payoffConfigs: portfolioVault.data.content.fields.config.fields.warmup_vault_config.fields.payoff_configs.map(function (x) {
+                                                return ({
+                                                    strikePct: x.fields.strike_pct,
+                                                    weight: x.fields.weight,
+                                                    isBuyer: x.fields.is_buyer,
+                                                    strike: x.fields.strike,
+                                                });
+                                            }),
+                                            // @ts-ignore
+                                            strikeIncrement: portfolioVault.data.content.fields.config.fields.warmup_vault_config.fields.strike_increment,
+                                            // @ts-ignore
+                                            decaySpeed: portfolioVault.data.content.fields.config.fields.warmup_vault_config.fields.decay_speed,
+                                            // @ts-ignore
+                                            initialPrice: portfolioVault.data.content.fields.config.fields.warmup_vault_config.fields.initial_price,
+                                            // @ts-ignore
+                                            finalPrice: portfolioVault.data.content.fields.config.fields.warmup_vault_config.fields.final_price,
+                                            // @ts-ignore
+                                            auctionDurationInMs: portfolioVault.data.content.fields.config.fields.warmup_vault_config.fields.auction_duration_in_ms,
+                                        },
+                                        upcomingVaultConfig: {
+                                            // @ts-ignore
+                                            payoffConfigs: portfolioVault.data.content.fields.config.fields.upcoming_vault_config.fields.payoff_configs.map(function (x) {
+                                                return ({
+                                                    strikePct: x.fields.strike_pct,
+                                                    weight: x.fields.weight,
+                                                    isBuyer: x.fields.is_buyer,
+                                                    strike: x.fields.strike,
+                                                });
+                                            }),
+                                            // @ts-ignore
+                                            strikeIncrement: portfolioVault.data.content.fields.config.fields.upcoming_vault_config.fields.strike_increment,
+                                            // @ts-ignore
+                                            decaySpeed: portfolioVault.data.content.fields.config.fields.upcoming_vault_config.fields.decay_speed,
+                                            // @ts-ignore
+                                            initialPrice: portfolioVault.data.content.fields.config.fields.upcoming_vault_config.fields.initial_price,
+                                            // @ts-ignore
+                                            finalPrice: portfolioVault.data.content.fields.config.fields.upcoming_vault_config.fields.final_price,
+                                            auctionDurationInMs: 
+                                            // @ts-ignore
+                                            portfolioVault.data.content.fields.config.fields.upcoming_vault_config.fields.auction_duration_in_ms,
+                                        },
+                                    };
+                                    auction = portfolioVault.data.content.fields.auction ? (0, dutch_1.parseAuction)(portfolioVault.data.content.fields.auction) : undefined;
+                                    authority = portfolioVault.data.content.fields.authority.fields.whitelist.fields.id.id;
+                                    map[info.index] = {
+                                        vaultId: vaultId,
+                                        typeArgs: typeArgs,
+                                        assets: assets,
+                                        info: info,
+                                        config: config,
+                                        depositVault: {},
+                                        bidVault: {},
+                                        auction: auction,
+                                        authority: authority,
+                                    };
+                                    return [2 /*return*/, map];
+                            }
+                        });
+                    }); }, Promise.resolve({}))];
+                case 3:
+                    portfolioVaults = _a.sent();
+                    return [4 /*yield*/, provider.getDynamicFields({ parentId: deposit_vault_registry })];
+                case 4:
+                    depositVaultIds = (_a.sent()).data
+                        .filter(function (x) { return (index ? x.name.value == index : true); })
+                        .map(function (x) { return x.objectId; });
+                    return [4 /*yield*/, provider.multiGetObjects({
+                            ids: depositVaultIds,
+                            options: { showContent: true },
+                        })];
+                case 5:
+                    (_a.sent())
+                        .filter(function (depositVault) { return depositVault.error == undefined; })
+                        .forEach(function (depositVault) {
+                        // @ts-ignore
+                        var index = depositVault.data.content.fields.name;
+                        // @ts-ignore
+                        var vault = (0, vault_1.parseDepositVault)(depositVault.data.content.fields.value);
+                        var tvl = BigInt(vault.activeSubVault.balance) + BigInt(vault.warmupSubVault.balance);
+                        portfolioVaults[index].tokenTvl = tvl;
+                        portfolioVaults[index].depositVault = vault;
+                    });
+                    return [4 /*yield*/, provider.getDynamicFields({ parentId: bid_vault_registry })];
+                case 6:
+                    bidVaultIds = (_a.sent()).data
+                        .filter(function (x) { return (index ? x.name.value == index : true); })
+                        .map(function (x) { return x.objectId; });
+                    return [4 /*yield*/, provider.multiGetObjects({
+                            ids: bidVaultIds,
+                            options: { showContent: true },
+                        })];
+                case 7:
+                    (_a.sent())
+                        .filter(function (bidVault) { return bidVault.error == undefined; })
+                        .forEach(function (bidVault) {
+                        // @ts-ignore
+                        portfolioVaults[bidVault.data.content.fields.name].bidVault = (0, vault_1.parseBidVault)(bidVault.data.content.fields.value);
+                    });
+                    // @ts-ignore
+                    return [2 /*return*/, portfolioVaults];
+            }
+        });
+    });
+}
+exports.getPortfolioVaults = getPortfolioVaults;
+function getPortfolioVaultAuctionDelayTsMs(provider, portfolio_vault) {
+    return __awaiter(this, void 0, void 0, function () {
+        var auctionDelayTsMs;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    auctionDelayTsMs = "0";
+                    return [4 /*yield*/, provider
+                            .getDynamicFieldObject({
+                            parentId: portfolio_vault.vaultId,
+                            name: {
+                                type: "vector<u8>",
+                                value: [
+                                    97, 117, 99, 116, 105, 111, 110, 95, 115, 116, 97, 114, 116, 95, 100, 101, 108, 97, 121, 95, 116, 115, 95, 109, 115,
+                                ],
+                            },
+                        })
+                            .then(function (result) {
+                            if (result.error == undefined) {
+                                // @ts-ignore
+                                auctionDelayTsMs = result.data.content.fields.value;
+                            }
+                        })];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/, auctionDelayTsMs];
+            }
+        });
+    });
+}
+exports.getPortfolioVaultAuctionDelayTsMs = getPortfolioVaultAuctionDelayTsMs;

package/lib/utils/typus-dov-single/registry.d.ts

@@ -0,0 +1,14 @@
+import { SuiClient } from "@mysten/sui.js/client";
+export interface Registry {
+    version: string;
+    numOfVault: string;
+    depositVaultRegistry: string;
+    bidVaultRegistry: string;
+    restrictActivationTimePeriod: {
+        fromTsMs: string;
+        toTsMs: string;
+    };
+    authority: string[];
+}
+export declare function getRegistry(provider: SuiClient, registry: string): Promise<Registry>;
+export declare function getPackageVersion(provider: SuiClient, packageId: string): Promise<bigint>;