@typus/typus-sdk 1.7.11 → 1.7.13

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

@@ -51,3 +51,62 @@ export declare function getUpdateConfigTx(config: TypusConfig, tx: Transaction,
         depositIncentiveBpDivisorDecimal?: string;
     };
 }[]): Promise<Transaction>;
+/**
+    public entry fun deposit_collateral_navi<TOKEN>(
+        registry: &mut Registry,
+        index: u64,
+        storage: &mut lending_core::storage::Storage,
+        pool: &mut lending_core::pool::Pool<TOKEN>,
+        asset: u8,
+        incentive_v2: &mut lending_core::incentive_v2::Incentive,
+        incentive_v3: &mut lending_core::incentive_v3::Incentive,
+        coin: Coin<TOKEN>,
+        clock: &Clock,
+        ctx: &mut TxContext,
+    ) {
+ */
+export declare function depositCollateralNavi(config: TypusConfig, tx: Transaction, input: {
+    typeArguments: string[];
+    index: string;
+    raiseCoins: string[];
+    raiseAmount: string;
+    naviStorage: string;
+    naviPool: string;
+    naviAsset: number;
+    naviIncentiveV2: string;
+    naviIncentiveV3: string;
+}): void;
+/**
+    public entry fun withdraw_collateral_navi<TOKEN>(
+        registry: &mut Registry,
+        index: u64,
+        oracle_config: &mut OracleConfig,
+        price_oracle: &mut PriceOracle,
+        supra_oracle_holder: &SupraOracle::SupraSValueFeed::OracleHolder,
+        pyth_price_info: &pyth::price_info::PriceInfoObject,
+        feed_address: address,
+        storage: &mut lending_core::storage::Storage,
+        pool: &mut lending_core::pool::Pool<TOKEN>,
+        asset: u8,
+        incentive_v2: &mut lending_core::incentive_v2::Incentive,
+        incentive_v3: &mut lending_core::incentive_v3::Incentive,
+        amount: Option<u64>,
+        clock: &Clock,
+        ctx: &mut TxContext,
+    ) {
+ */
+export declare function withdrawCollateralNavi(config: TypusConfig, tx: Transaction, input: {
+    typeArguments: string[];
+    index: string;
+    naviOracleConfig: string;
+    naviPriceOracle: string;
+    naviSupraOracleHolder: string;
+    naviPythPriceInfo: string;
+    naviFeedAddress: string;
+    naviStorage: string;
+    naviPool: string;
+    naviAsset: number;
+    naviIncentiveV2: string;
+    naviIncentiveV3: string;
+    amount: string | undefined;
+}): void;

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

@@ -37,6 +37,10 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getUpdateConfigTx = getUpdateConfigTx;
+exports.depositCollateralNavi = depositCollateralNavi;
+exports.withdrawCollateralNavi = withdrawCollateralNavi;
+var constants_1 = require("../../src/constants");
+var utils_1 = require("../../src/utils");
 /**
     public(friend) entry fun update_config(
         registry: &mut Registry,
@@ -100,3 +104,76 @@ function getUpdateConfigTx(config, tx, requests) {
         });
     });
 }
+/**
+    public entry fun deposit_collateral_navi<TOKEN>(
+        registry: &mut Registry,
+        index: u64,
+        storage: &mut lending_core::storage::Storage,
+        pool: &mut lending_core::pool::Pool<TOKEN>,
+        asset: u8,
+        incentive_v2: &mut lending_core::incentive_v2::Incentive,
+        incentive_v3: &mut lending_core::incentive_v3::Incentive,
+        coin: Coin<TOKEN>,
+        clock: &Clock,
+        ctx: &mut TxContext,
+    ) {
+ */
+function depositCollateralNavi(config, tx, input) {
+    var coin = (0, utils_1.splitCoins)(tx, input.typeArguments[0], input.raiseCoins, input.raiseAmount);
+    tx.moveCall({
+        target: "".concat(config.package.dovSingle, "::tds_authorized_entry::deposit_collateral_navi"),
+        typeArguments: input.typeArguments,
+        arguments: [
+            tx.object(config.registry.dov.dovSingle),
+            tx.pure.u64(input.index),
+            tx.object(input.naviStorage),
+            tx.object(input.naviPool),
+            tx.pure.u8(input.naviAsset),
+            tx.object(input.naviIncentiveV2),
+            tx.object(input.naviIncentiveV3),
+            tx.object(coin),
+            tx.object(constants_1.CLOCK),
+        ],
+    });
+}
+/**
+    public entry fun withdraw_collateral_navi<TOKEN>(
+        registry: &mut Registry,
+        index: u64,
+        oracle_config: &mut OracleConfig,
+        price_oracle: &mut PriceOracle,
+        supra_oracle_holder: &SupraOracle::SupraSValueFeed::OracleHolder,
+        pyth_price_info: &pyth::price_info::PriceInfoObject,
+        feed_address: address,
+        storage: &mut lending_core::storage::Storage,
+        pool: &mut lending_core::pool::Pool<TOKEN>,
+        asset: u8,
+        incentive_v2: &mut lending_core::incentive_v2::Incentive,
+        incentive_v3: &mut lending_core::incentive_v3::Incentive,
+        amount: Option<u64>,
+        clock: &Clock,
+        ctx: &mut TxContext,
+    ) {
+ */
+function withdrawCollateralNavi(config, tx, input) {
+    tx.moveCall({
+        target: "".concat(config.package.dovSingle, "::tds_authorized_entry::withdraw_collateral_navi"),
+        typeArguments: input.typeArguments,
+        arguments: [
+            tx.object(config.registry.dov.dovSingle),
+            tx.pure.u64(input.index),
+            tx.object(input.naviOracleConfig),
+            tx.object(input.naviPriceOracle),
+            tx.object(input.naviSupraOracleHolder),
+            tx.object(input.naviPythPriceInfo),
+            tx.pure.address(input.naviFeedAddress),
+            tx.object(input.naviStorage),
+            tx.object(input.naviPool),
+            tx.pure.u8(input.naviAsset),
+            tx.object(input.naviIncentiveV2),
+            tx.object(input.naviIncentiveV3),
+            tx.pure.option("u64", input.amount),
+            tx.object(constants_1.CLOCK),
+        ],
+    });
+}

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

@@ -21,7 +21,7 @@ export declare function addOtcConfig(config: TypusConfig, tx: Transaction, input
     price: string;
     fee_bp: string;
     expiration_ts_ms: string;
-}): Promise<void>;
+}): void;
 /**
     entry fun remove_otc_config(
         registry: &mut Registry,

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

@@ -60,24 +60,19 @@ var constants_2 = require("../../src/constants");
     ) {
  */
 function addOtcConfig(config, tx, input) {
-    return __awaiter(this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            tx.moveCall({
-                target: "".concat(config.package.dovSingle, "::tds_otc_entry::add_otc_config"),
-                typeArguments: [],
-                arguments: [
-                    tx.object(config.registry.dov.dovSingle),
-                    tx.pure.address(input.user),
-                    tx.pure.u64(input.index),
-                    tx.pure.u64(input.round),
-                    tx.pure.u64(input.size),
-                    tx.pure.u64(input.price),
-                    tx.pure.u64(input.fee_bp),
-                    tx.pure.u64(input.expiration_ts_ms),
-                ],
-            });
-            return [2 /*return*/];
-        });
+    tx.moveCall({
+        target: "".concat(config.package.dovSingle, "::tds_otc_entry::add_otc_config"),
+        typeArguments: [],
+        arguments: [
+            tx.object(config.registry.dov.dovSingle),
+            tx.pure.address(input.user),
+            tx.pure.u64(input.index),
+            tx.pure.u64(input.round),
+            tx.pure.u64(input.size),
+            tx.pure.u64(input.price),
+            tx.pure.u64(input.fee_bp),
+            tx.pure.u64(input.expiration_ts_ms),
+        ],
     });
 }
 /**
@@ -113,10 +108,10 @@ function otc(config, tx, input) {
     return __awaiter(this, void 0, void 0, function () {
         var coin, balance;
         return __generator(this, function (_a) {
-            coin = (0, utils_1.splitCoins)(tx, input.typeArguments[0], input.coins, input.amount);
+            coin = (0, utils_1.splitCoins)(tx, input.typeArguments[1], input.coins, input.amount);
             balance = tx.moveCall({
                 target: "0x2::coin::into_balance",
-                typeArguments: [input.typeArguments[0]],
+                typeArguments: [input.typeArguments[1]],
                 arguments: [tx.object(coin)],
             });
             tx.moveCall({

package/dist/src/typus-hedge/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./user-entry";
+export * from "./view-function";

package/dist/src/typus-hedge/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./user-entry"), exports);
+__exportStar(require("./view-function"), exports);
+// export * from "./authority-entry";
+// export * from "./function";
+// export * from "./history";
+// export * from "./token-user-entry";

package/dist/src/typus-hedge/user-entry.d.ts

@@ -0,0 +1,74 @@
+import { Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
+import { TypusConfig } from "../../src/utils";
+/**
+    public fun raise_fund<MAIN_TOKEN, HEDGE_TOKEN>(
+        typus_version: &TypusVersion,
+        typus_leaderboard_registry: &mut TypusLeaderboardRegistry,
+        typus_user_registry: &mut TypusUserRegistry,
+        version: &Version,
+        registry: &mut Registry,
+        index: u64,
+        account: Option<address>,
+        raise_main_balance: Balance<MAIN_TOKEN>,
+        raise_hedge_balance: Balance<HEDGE_TOKEN>,
+        raise_from_deactivating: u64,
+        raise_from_inactive: u64,
+        clock: &Clock,
+        ctx: &mut TxContext,
+    ) {
+ */
+export declare function raiseFund(config: TypusConfig, tx: Transaction, input: {
+    typeArguments: string[];
+    index: string;
+    raiseMainCoins: string[];
+    raiseMainAmount: string;
+    raiseHedgeCoins: string[];
+    raiseHedgeAmount: string;
+    raiseFromDeactivating: boolean;
+    raiseFromInactive: boolean;
+}): void;
+/**
+    public fun reduce_fund<MAIN_TOKEN, HEDGE_TOKEN>(
+        typus_version: &TypusVersion,
+        typus_leaderboard_registry: &mut TypusLeaderboardRegistry,
+        typus_user_registry: &mut TypusUserRegistry,
+        version: &mut Version,
+        registry: &mut Registry,
+        index: u64,
+        account: Option<address>,
+        reduce_from_warmup: u64,
+        reduce_from_active: u64,
+        reduce_from_inactive: bool,
+        fee: Balance<SUI>,
+        clock: &Clock,
+        ctx: &mut TxContext,
+    ): (Balance<MAIN_TOKEN>, Balance<HEDGE_TOKEN>) {
+ */
+export declare function reduceFund(config: TypusConfig, tx: Transaction, input: {
+    typeArguments: string[];
+    index: string;
+    reduceFromWarmup: string;
+    reduceFromActive: string;
+    reduceFromInactive: boolean;
+    feeAmount: string;
+    user: string;
+}): void;
+/**
+    public fun snapshot(
+        typus_version: &TypusVersion,
+        typus_leaderboard_registry: &mut TypusLeaderboardRegistry,
+        typus_user_registry: &mut TypusUserRegistry,
+        version: &mut Version,
+        registry: &mut Registry,
+        index: u64,
+        account: Option<address>,
+        clock: &Clock,
+        ctx: &mut TxContext,
+    ) {
+ */
+export declare function snapshot(config: TypusConfig, tx: Transaction, input: {
+    typeArguments: string[];
+    index: string;
+    receipts: string[] | TransactionObjectArgument[];
+    user: string;
+}): void;

package/dist/src/typus-hedge/user-entry.js

@@ -0,0 +1,155 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.raiseFund = raiseFund;
+exports.reduceFund = reduceFund;
+exports.snapshot = snapshot;
+var utils_1 = require("@mysten/sui/dist/cjs/utils");
+var constants_1 = require("../../src/constants");
+var utils_2 = require("../../src/utils");
+/**
+    public fun raise_fund<MAIN_TOKEN, HEDGE_TOKEN>(
+        typus_version: &TypusVersion,
+        typus_leaderboard_registry: &mut TypusLeaderboardRegistry,
+        typus_user_registry: &mut TypusUserRegistry,
+        version: &Version,
+        registry: &mut Registry,
+        index: u64,
+        account: Option<address>,
+        raise_main_balance: Balance<MAIN_TOKEN>,
+        raise_hedge_balance: Balance<HEDGE_TOKEN>,
+        raise_from_deactivating: u64,
+        raise_from_inactive: u64,
+        clock: &Clock,
+        ctx: &mut TxContext,
+    ) {
+ */
+function raiseFund(config, tx, input) {
+    var mainCoin = (0, utils_2.splitCoins)(tx, input.typeArguments[0], input.raiseMainCoins, input.raiseMainAmount);
+    var hedgeCoin = (0, utils_2.splitCoins)(tx, input.typeArguments[1], input.raiseHedgeCoins, input.raiseHedgeAmount);
+    var mainBalance = tx.moveCall({
+        target: "0x2::coin::into_balance",
+        typeArguments: [input.typeArguments[0]],
+        arguments: [tx.object(mainCoin)],
+    });
+    var hedgeBalance = tx.moveCall({
+        target: "0x2::coin::into_balance",
+        typeArguments: [input.typeArguments[1]],
+        arguments: [tx.object(hedgeCoin)],
+    });
+    tx.moveCall({
+        target: "".concat(config.package.hedge.hedge, "::typus_hedge::raise_fund"),
+        typeArguments: input.typeArguments,
+        arguments: [
+            tx.object(config.version.typus),
+            tx.object(config.registry.typus.leaderboard),
+            tx.object(config.registry.typus.user),
+            tx.object(config.version.hedge.hedge),
+            tx.object(config.registry.hedge),
+            tx.pure.u64(input.index),
+            tx.pure.option("address", null),
+            tx.object(mainBalance),
+            tx.object(hedgeBalance),
+            tx.pure.bool(input.raiseFromDeactivating),
+            tx.pure.bool(input.raiseFromInactive),
+            tx.object(constants_1.CLOCK),
+        ],
+    });
+}
+/**
+    public fun reduce_fund<MAIN_TOKEN, HEDGE_TOKEN>(
+        typus_version: &TypusVersion,
+        typus_leaderboard_registry: &mut TypusLeaderboardRegistry,
+        typus_user_registry: &mut TypusUserRegistry,
+        version: &mut Version,
+        registry: &mut Registry,
+        index: u64,
+        account: Option<address>,
+        reduce_from_warmup: u64,
+        reduce_from_active: u64,
+        reduce_from_inactive: bool,
+        fee: Balance<SUI>,
+        clock: &Clock,
+        ctx: &mut TxContext,
+    ): (Balance<MAIN_TOKEN>, Balance<HEDGE_TOKEN>) {
+ */
+function reduceFund(config, tx, input) {
+    var _a = __read(tx.splitCoins(tx.gas, [tx.pure.u64(input.feeAmount)]), 1), feeCoin = _a[0];
+    var feeBalance = tx.moveCall({
+        target: "0x2::coin::into_balance",
+        typeArguments: [utils_1.SUI_TYPE_ARG],
+        arguments: [tx.object(feeCoin)],
+    });
+    var result = tx.moveCall({
+        target: "".concat(config.package.hedge.hedge, "::typus_hedge::reduce_fund"),
+        typeArguments: input.typeArguments,
+        arguments: [
+            tx.object(config.version.typus),
+            tx.object(config.registry.typus.leaderboard),
+            tx.object(config.registry.typus.user),
+            tx.object(config.version.hedge.hedge),
+            tx.object(config.registry.hedge),
+            tx.pure.u64(input.index),
+            tx.pure.option("address", null),
+            tx.pure.u64(input.reduceFromWarmup),
+            tx.pure.u64(input.reduceFromActive),
+            tx.pure.bool(input.reduceFromInactive),
+            tx.object(feeBalance),
+            tx.object(constants_1.CLOCK),
+        ],
+    });
+    tx.moveCall({
+        target: "".concat(config.package.framework, "::utils::transfer_balance"),
+        typeArguments: [input.typeArguments[0]],
+        arguments: [tx.object(result[0]), tx.pure.address(input.user)],
+    });
+    tx.moveCall({
+        target: "".concat(config.package.framework, "::utils::transfer_balance"),
+        typeArguments: [input.typeArguments[1]],
+        arguments: [tx.object(result[1]), tx.pure.address(input.user)],
+    });
+}
+/**
+    public fun snapshot(
+        typus_version: &TypusVersion,
+        typus_leaderboard_registry: &mut TypusLeaderboardRegistry,
+        typus_user_registry: &mut TypusUserRegistry,
+        version: &mut Version,
+        registry: &mut Registry,
+        index: u64,
+        account: Option<address>,
+        clock: &Clock,
+        ctx: &mut TxContext,
+    ) {
+ */
+function snapshot(config, tx, input) {
+    tx.moveCall({
+        target: "".concat(config.package.hedge.hedge, "::typus_hedge::snapshot"),
+        typeArguments: input.typeArguments,
+        arguments: [
+            tx.object(config.version.typus),
+            tx.object(config.registry.typus.leaderboard),
+            tx.object(config.registry.typus.user),
+            tx.object(config.version.hedge.hedge),
+            tx.object(config.registry.hedge),
+            tx.pure.u64(input.index),
+            tx.pure.option("address", null),
+            tx.object(constants_1.CLOCK),
+        ],
+    });
+}

package/dist/src/typus-hedge/view-function.d.ts

@@ -0,0 +1,75 @@
+import { TypusConfig } from "../../src/utils";
+import { TypusBidReceipt } from "../../src/auto-bid/view-function";
+export interface Vault {
+    id: string;
+    depositToken: string;
+    rewardToken: string[];
+    info: Info;
+    config: Config;
+    share: BigVector;
+    shareSupply: ShareSupply;
+    u64Padding: string[];
+    bcsPadding: string[];
+}
+export interface Info {
+    index: string;
+    round: string;
+    portfolio_vault_index: string;
+    refresh_ts_ms: string;
+    status: string;
+    lending_enabled: string;
+    price_mbp: string;
+    mbp_incentivised: string;
+    fixed_incentivised: string;
+    token_decimal: string;
+    lending_apr_mbp: string;
+    creation_ts_ms: string;
+    dov_vault_index_add_one_up: string;
+}
+export interface Config {
+    capacity: string;
+    lot_size: string;
+    min_size: string;
+    fee_bp: string;
+    utilization_rate_bp: string;
+    exp_per_hour_bp: string;
+    incentive_mbp: string;
+    incentive_fixed: string;
+    point_per_hour_bp: string;
+    exercise_fee_bp: string;
+    exit_fee_bp: string;
+    exit_fee_amount: string;
+}
+export interface ShareSupply {
+    active_share: string;
+    deactivating_share: string;
+    inactive_share: string;
+    warmup_share: string;
+    snapshot_share: string;
+    reward_share: string[];
+}
+export interface BigVector {
+    id: string;
+    element_type: string;
+    slice_idx: string;
+    slice_size: number;
+    length: string;
+}
+export declare function getBigVectorData(config: TypusConfig, bigVector: BigVector): Promise<any[]>;
+export declare function getVaultData(config: TypusConfig, input: {
+    indexes: string[];
+}): Promise<{
+    [key: string]: [Vault, TypusBidReceipt | null];
+}>;
+export interface Share {
+    user: string;
+    share: ShareSupply;
+    u64Padding: string[];
+    bcsPadding: string[];
+}
+export declare function getShareData(config: TypusConfig, input: {
+    user: string;
+    indexes: string[];
+}): Promise<{
+    [key: string]: Share[];
+}>;

package/dist/src/typus-hedge/view-function.js

@@ -0,0 +1,269 @@
+"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 = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["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.getBigVectorData = getBigVectorData;
+exports.getVaultData = getVaultData;
+exports.getShareData = getShareData;
+var transactions_1 = require("@mysten/sui/transactions");
+var client_1 = require("@mysten/sui/client");
+var bcs_1 = require("@mysten/bcs");
+var utils_1 = require("../../src/utils");
+var constants_1 = require("../../src/constants");
+function getBigVectorData(config, bigVector) {
+    return __awaiter(this, void 0, void 0, function () {
+        var provider, results, i, df, result;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    provider = new client_1.SuiClient({ url: config.rpcEndpoint });
+                    results = [];
+                    i = 0;
+                    _b.label = 1;
+                case 1:
+                    if (!(i <= Number(bigVector.slice_idx))) return [3 /*break*/, 4];
+                    return [4 /*yield*/, provider.getDynamicFieldObject({
+                            parentId: bigVector.id,
+                            name: {
+                                type: "u64",
+                                value: "".concat(i),
+                            },
+                        })];
+                case 2:
+                    df = _b.sent();
+                    result = (_a = df.data) === null || _a === void 0 ? void 0 : _a.content.fields.value.fields.vector.map(function (x) { return x.fields; });
+                    results = results.concat(result);
+                    _b.label = 3;
+                case 3:
+                    i++;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/, results];
+            }
+        });
+    });
+}
+function getVaultData(config, input) {
+    return __awaiter(this, void 0, void 0, function () {
+        var provider, transaction, results, bytes, reader, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    provider = new client_1.SuiClient({ url: config.rpcEndpoint });
+                    transaction = new transactions_1.Transaction();
+                    transaction.moveCall({
+                        target: "".concat(config.package.safu, "::view_function::get_vault_data_bcs"),
+                        typeArguments: ["".concat(config.package.framework, "::vault::TypusBidReceipt")],
+                        arguments: [transaction.object(config.registry.safu.safu), transaction.pure.vector("u64", input.indexes)],
+                    });
+                    return [4 /*yield*/, provider.devInspectTransactionBlock({ transactionBlock: transaction, sender: constants_1.SENDER })];
+                case 1:
+                    results = (_a.sent()).results;
+                    bytes = results[results.length - 1].returnValues[0][0];
+                    reader = new bcs_1.BcsReader(new Uint8Array(bytes));
+                    result = {};
+                    reader.readVec(function (reader) {
+                        reader.readULEB();
+                        var id = (0, utils_1.AddressFromBytes)(reader.readBytes(32));
+                        var depositToken = String.fromCharCode.apply(null, Array.from(reader.readBytes(reader.readULEB())));
+                        var rewardToken = reader.readVec(function (reader) {
+                            return String.fromCharCode.apply(null, Array.from(reader.readBytes(reader.readULEB())));
+                        });
+                        var infoArray = reader.readVec(function (reader) {
+                            return reader.read64();
+                        });
+                        var configArray = reader.readVec(function (reader) {
+                            return reader.read64();
+                        });
+                        var info = {
+                            index: infoArray[0],
+                            round: infoArray[1],
+                            portfolio_vault_index: infoArray[2],
+                            refresh_ts_ms: infoArray[3],
+                            status: infoArray[4],
+                            lending_enabled: infoArray[5],
+                            price_mbp: infoArray[6],
+                            mbp_incentivised: infoArray[7],
+                            fixed_incentivised: infoArray[8],
+                            token_decimal: infoArray[9],
+                            lending_apr_mbp: infoArray[10],
+                            creation_ts_ms: infoArray[11],
+                            dov_vault_index_add_one_up: infoArray[12],
+                        };
+                        var config = {
+                            capacity: configArray[0],
+                            lot_size: configArray[1],
+                            min_size: configArray[2],
+                            fee_bp: configArray[3],
+                            utilization_rate_bp: configArray[4],
+                            exp_per_hour_bp: configArray[5],
+                            incentive_mbp: configArray[6],
+                            incentive_fixed: configArray[7],
+                            point_per_hour_bp: configArray[8],
+                            exercise_fee_bp: configArray[9],
+                            exit_fee_bp: configArray[10],
+                            exit_fee_amount: configArray[11],
+                        };
+                        // skip BigVector
+                        var bigVector = {
+                            id: (0, utils_1.AddressFromBytes)(reader.readBytes(32)),
+                            element_type: String.fromCharCode.apply(null, Array.from(reader.readBytes(reader.readULEB()))), // element_type
+                            slice_idx: reader.read64(), // slice_idx
+                            slice_size: reader.read32(), // slice_size
+                            length: reader.read64(), // length
+                        };
+                        var shareSupplyArray = reader.readVec(function (reader) {
+                            return reader.read64();
+                        });
+                        var shareSupply = {
+                            active_share: shareSupplyArray[0],
+                            deactivating_share: shareSupplyArray[1],
+                            inactive_share: shareSupplyArray[2],
+                            warmup_share: shareSupplyArray[3],
+                            snapshot_share: shareSupplyArray[4],
+                            reward_share: shareSupplyArray.slice(5),
+                        };
+                        var u64Padding = reader.readVec(function (reader) {
+                            return reader.read64();
+                        });
+                        var bcsPadding = reader.readVec(function (reader) {
+                            return reader.read8();
+                        });
+                        var has_bid_receipt = reader.read8() > 0;
+                        if (has_bid_receipt) {
+                            result[info.index] = [
+                                {
+                                    id: id,
+                                    depositToken: depositToken,
+                                    rewardToken: rewardToken,
+                                    info: info,
+                                    config: config,
+                                    share: bigVector,
+                                    shareSupply: shareSupply,
+                                    u64Padding: u64Padding,
+                                    bcsPadding: bcsPadding,
+                                },
+                                {
+                                    id: (0, utils_1.AddressFromBytes)(reader.readBytes(32)),
+                                    vid: (0, utils_1.AddressFromBytes)(reader.readBytes(32)),
+                                    index: reader.read64(),
+                                    metadata: String.fromCharCode.apply(null, Array.from(reader.readBytes(reader.readULEB()))),
+                                    u64_padding: reader.readVec(function (reader) {
+                                        return reader.read64();
+                                    }),
+                                },
+                            ];
+                        }
+                        else {
+                            result[info.index] = [
+                                {
+                                    id: id,
+                                    depositToken: depositToken,
+                                    rewardToken: rewardToken,
+                                    info: info,
+                                    config: config,
+                                    share: bigVector,
+                                    shareSupply: shareSupply,
+                                    u64Padding: u64Padding,
+                                    bcsPadding: bcsPadding,
+                                },
+                                null,
+                            ];
+                        }
+                    });
+                    return [2 /*return*/, result];
+            }
+        });
+    });
+}
+function getShareData(config, input) {
+    return __awaiter(this, void 0, void 0, function () {
+        var provider, transaction, results, bytes, reader, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    provider = new client_1.SuiClient({ url: config.rpcEndpoint });
+                    transaction = new transactions_1.Transaction();
+                    transaction.moveCall({
+                        target: "".concat(config.package.safu, "::view_function::get_share_data_bcs"),
+                        typeArguments: [],
+                        arguments: [
+                            transaction.object(config.registry.safu.safu),
+                            transaction.pure.address(input.user),
+                            transaction.pure.vector("u64", input.indexes),
+                        ],
+                    });
+                    return [4 /*yield*/, provider.devInspectTransactionBlock({ transactionBlock: transaction, sender: constants_1.SENDER })];
+                case 1:
+                    results = (_a.sent()).results;
+                    bytes = results[results.length - 1].returnValues[0][0];
+                    reader = new bcs_1.BcsReader(new Uint8Array(bytes));
+                    result = {};
+                    reader.readVec(function (reader, i) {
+                        reader.read8();
+                        var share = reader.readVec(function (reader) {
+                            var user = (0, utils_1.AddressFromBytes)(reader.readBytes(32));
+                            var shareSupplyArray = reader.readVec(function (reader) {
+                                return reader.read64();
+                            });
+                            var shareSupply = {
+                                active_share: shareSupplyArray[0],
+                                deactivating_share: shareSupplyArray[1],
+                                inactive_share: shareSupplyArray[2],
+                                warmup_share: shareSupplyArray[3],
+                                snapshot_share: shareSupplyArray[4],
+                                reward_share: shareSupplyArray.slice(5),
+                            };
+                            return {
+                                user: user,
+                                share: shareSupply,
+                                u64Padding: reader.readVec(function (reader) {
+                                    return reader.read64();
+                                }),
+                                bcsPadding: reader.readVec(function (reader) {
+                                    return reader.read8();
+                                }),
+                            };
+                        });
+                        var index = input.indexes.pop();
+                        result[index] = share;
+                    });
+                    return [2 /*return*/, result];
+            }
+        });
+    });
+}

package/dist/src/utils/api/price.js

@@ -150,7 +150,6 @@ function getPythLatestPrice() {
                         var price = p.price.price / Math.pow(10, -p.price.expo);
                         map.set(token, price);
                     });
-                    console.log(map);
                     return [2 /*return*/, map];
                 case 3: return [2 /*return*/];
             }
@@ -288,8 +287,8 @@ var pythId = {
     "04cfeb7b143eb9c48e9b074125c1a3447b85f59c31164dc20c1beaa6f21f2b6b": "BLUE",
     "5fc11ffe4975b624be495be038da30e30bee2004d8ae6282b5364577ef4ca92c": "BLUB",
     "765d2ba906dbc32ca17cc11f5310a89e9ee1f6420508c63861f2f8ba4ee34bb2": "XAU",
-    "eba0732395fae9dec4bae12e52760b35fc1c5671e2da8b449c9af4efe5d54341": "WAL",
+    eba0732395fae9dec4bae12e52760b35fc1c5671e2da8b449c9af4efe5d54341: "WAL",
     "4279e31cc369bbcc2faf022b382b080e32a8e689ff20fbc530d2a603eb6cd98b": "HYPE",
-    "ec5d399846a9209f3fe5881d70aae9268c94339ff9817e8d18ff19fa05eea1c8": "XRP",
+    ec5d399846a9209f3fe5881d70aae9268c94339ff9817e8d18ff19fa05eea1c8: "XRP",
 };
 // getPythLatestPrice();

package/dist/src/utils/sponsoredTx.d.ts

@@ -0,0 +1,8 @@
+import { Transaction } from "@mysten/sui/transactions";
+import { SuiClient } from "@mysten/sui/client";
+export declare function getSponsoredTx(provider: SuiClient, sender: string, tx: Transaction): Promise<sponsoredResponse>;
+interface sponsoredResponse {
+    txBytes: string;
+    sponsorSig: string;
+}
+export {};

package/dist/src/utils/sponsoredTx.js

@@ -0,0 +1,72 @@
+"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 = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["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.getSponsoredTx = getSponsoredTx;
+var sui_1 = require("@shinami/clients/sui");
+function getSponsoredTx(provider, sender, tx) {
+    return __awaiter(this, void 0, void 0, function () {
+        var gaslessTx, body, apiUrl, headers, response, sponsoredResponse;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, sui_1.buildGaslessTransaction)(tx, {
+                        sui: provider,
+                        sender: sender,
+                    })];
+                case 1:
+                    gaslessTx = _a.sent();
+                    body = JSON.stringify(gaslessTx);
+                    apiUrl = "https://sponsored-gas-752051381467.asia-southeast1.run.app";
+                    headers = {
+                        "Content-Type": "application/json",
+                    };
+                    return [4 /*yield*/, fetch(apiUrl, {
+                            method: "POST",
+                            headers: headers,
+                            body: body,
+                        })];
+                case 2:
+                    response = _a.sent();
+                    return [4 /*yield*/, response.json()];
+                case 3:
+                    sponsoredResponse = (_a.sent());
+                    // console.log(sponsoredResponse);
+                    return [2 /*return*/, sponsoredResponse];
+            }
+        });
+    });
+}

package/dist/src/utils/tools.d.ts

@@ -1,5 +1,5 @@
-import BigNumber from "bignumber.js";
 import { Transaction } from "@mysten/sui/transactions";
+import BigNumber from "bignumber.js";
 export declare const sleep: (ms: number) => Promise<unknown>;
 export declare const prettify_big_number: (value: any, decimal: any) => string;
 export declare function U64FromBytes(x: any): bigint;
@@ -11,3 +11,5 @@ export declare function splitCoins(tx: Transaction, token: string, coins: string
     $kind: "NestedResult";
     NestedResult: [number, number];
 };
+export declare function promptYesNo(question: string): Promise<boolean>;
+export declare function getNumberStringWithDecimal(input: string, decimal: number): string;

package/dist/src/utils/tools.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __read = (this && this.__read) || function (o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
@@ -23,9 +56,12 @@ exports.countFloating = exports.checkNumber = exports.insertAt = exports.prettif
 exports.U64FromBytes = U64FromBytes;
 exports.AddressFromBytes = AddressFromBytes;
 exports.splitCoins = splitCoins;
-var bignumber_js_1 = __importDefault(require("bignumber.js"));
-var constants_1 = require("../../src/constants");
+exports.promptYesNo = promptYesNo;
+exports.getNumberStringWithDecimal = getNumberStringWithDecimal;
 var utils_1 = require("@mysten/sui/utils");
+var constants_1 = require("../../src/constants");
+var readline = __importStar(require("readline"));
+var bignumber_js_1 = __importDefault(require("bignumber.js"));
 var sleep = function (ms) { return new Promise(function (resolve) { return setTimeout(resolve, ms); }); };
 exports.sleep = sleep;
 var prettify_big_number = function (value, decimal) {
@@ -92,3 +128,27 @@ function splitCoins(tx, token, coins, amount) {
     }
     return coin;
 }
+function promptYesNo(question) {
+    var rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise(function (resolve) {
+        rl.question("".concat(question, " [y/N] "), function (answer) {
+            var normalizedAnswer = answer.toLowerCase();
+            if (normalizedAnswer === "y" || normalizedAnswer === "yes") {
+                resolve(true);
+            }
+            else {
+                resolve(false);
+            }
+            rl.close();
+        });
+    });
+}
+function getNumberStringWithDecimal(input, decimal) {
+    input = input.padStart(decimal, "0");
+    var integer = input.slice(0, input.length - decimal).replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+    var float = input.slice(input.length - decimal, input.length);
+    return "".concat(integer == "" ? "0" : integer, ".").concat(float);
+}

package/package.json

@@ -2,12 +2,13 @@
     "name": "@typus/typus-sdk",
     "author": "Typus",
     "description": "typus sdk",
-    "version": "1.7.11",
+    "version": "1.7.13",
     "dependencies": {
         "@mysten/bcs": "1.6.1",
         "@mysten/kiosk": "0.12.6",
         "@mysten/sui": "1.30.0",
         "@pythnetwork/pyth-sui-js": "^2.1.0",
+        "@shinami/clients": "^0.9.6",
         "@typemove/sui": "^1.6.1",
         "@types/node": "^20.5.7",
         "bignumber.js": "^9.1.2",