@typus/typus-sdk 1.1.57 → 1.2.0

package/lib/utils/auto-bid/user-entry.d.ts

@@ -0,0 +1,27 @@
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+/**
+    entry fun new_strategy<B_TOKEN>(
+        strategy_pool: &mut StrategyPool,
+        vault_index: u64,
+        signal_index: u64,
+        size: u64,
+        price_percentage: u64,
+        max_times: u64,
+        target_rounds: vector<u64>,
+        coin: Coin<B_TOKEN>,
+        ctx: &mut TxContext
+    )
+*/
+export declare function getNewStrategyTx(gasBudget: number, packageId: string, typeArguments: string[], // D_TOKEN, B_TOKEN
+strategy_pool: string, vault_index: string, signal_index: string, coins: string[], amount: string, size: string, price_percentage: string, max_times: string, target_rounds: string[]): TransactionBlock;
+/**
+    entry fun close_strategy<D_TOKEN, B_TOKEN>(
+        strategy_pool: &mut StrategyPoolV2,
+        vault_index: u64,
+        signal_index: u64,
+        strategy_index: u64,
+        ctx: &mut TxContext
+    )
+*/
+export declare function getCloseStrategyTx(gasBudget: number, packageId: string, typeArguments: string[], // D_TOKEN, B_TOKEN
+strategy_pool: string, vault_index: string, signal_index: string, strategy_index: string): TransactionBlock;

package/lib/utils/auto-bid/user-entry.js

@@ -0,0 +1,102 @@
+"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.getCloseStrategyTx = exports.getNewStrategyTx = void 0;
+var transactions_1 = require("@mysten/sui.js/transactions");
+/**
+    entry fun new_strategy<B_TOKEN>(
+        strategy_pool: &mut StrategyPool,
+        vault_index: u64,
+        signal_index: u64,
+        size: u64,
+        price_percentage: u64,
+        max_times: u64,
+        target_rounds: vector<u64>,
+        coin: Coin<B_TOKEN>,
+        ctx: &mut TxContext
+    )
+*/
+function getNewStrategyTx(gasBudget, packageId, typeArguments, // D_TOKEN, B_TOKEN
+strategy_pool, vault_index, signal_index, coins, amount, size, price_percentage, max_times, target_rounds) {
+    var tx = new transactions_1.TransactionBlock();
+    if (
+    // B_TOKEN
+    typeArguments[1] == "0x2::sui::SUI" ||
+        typeArguments[1] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI") {
+        var _a = __read(tx.splitCoins(tx.gas, [tx.pure(amount)]), 1), input_coin = _a[0];
+        tx.moveCall({
+            target: "".concat(packageId, "::auto_bid::new_strategy"),
+            typeArguments: typeArguments,
+            arguments: [
+                tx.object(strategy_pool),
+                tx.pure(vault_index),
+                tx.pure(signal_index),
+                tx.pure(size),
+                tx.pure(price_percentage),
+                tx.pure(max_times),
+                tx.pure(target_rounds),
+                input_coin,
+            ],
+        });
+    }
+    else {
+        var coin = coins.pop();
+        if (coins.length > 0) {
+            tx.mergeCoins(tx.object(coin), coins.map(function (coin) { return tx.object(coin); }));
+        }
+        var _b = __read(tx.splitCoins(tx.object(coin), [tx.pure(amount)]), 1), input_coin = _b[0];
+        tx.moveCall({
+            target: "".concat(packageId, "::auto_bid::new_strategy"),
+            typeArguments: typeArguments,
+            arguments: [
+                tx.object(strategy_pool),
+                tx.pure(vault_index),
+                tx.pure(signal_index),
+                tx.pure(size),
+                tx.pure(price_percentage),
+                tx.pure(max_times),
+                tx.pure(target_rounds),
+                input_coin,
+            ],
+        });
+    }
+    tx.setGasBudget(gasBudget);
+    return tx;
+}
+exports.getNewStrategyTx = getNewStrategyTx;
+/**
+    entry fun close_strategy<D_TOKEN, B_TOKEN>(
+        strategy_pool: &mut StrategyPoolV2,
+        vault_index: u64,
+        signal_index: u64,
+        strategy_index: u64,
+        ctx: &mut TxContext
+    )
+*/
+function getCloseStrategyTx(gasBudget, packageId, typeArguments, // D_TOKEN, B_TOKEN
+strategy_pool, vault_index, signal_index, strategy_index) {
+    var tx = new transactions_1.TransactionBlock();
+    tx.moveCall({
+        target: "".concat(packageId, "::auto_bid::close_strategy"),
+        typeArguments: typeArguments,
+        arguments: [tx.object(strategy_pool), tx.pure(vault_index), tx.pure(signal_index), tx.pure(strategy_index)],
+    });
+    tx.setGasBudget(gasBudget);
+    return tx;
+}
+exports.getCloseStrategyTx = getCloseStrategyTx;

package/lib/utils/auto-bid/view-function.d.ts

@@ -0,0 +1,33 @@
+import { SuiClient } from "@mysten/sui.js/client";
+export declare function getUserStrategies(provider: SuiClient, packageId: string, strategyPool: string, user: string): Promise<StrategyV2[]>;
+export declare function getVaults(provider: SuiClient, strategyPool: string): Promise<void>;
+export interface StrategyPoolV2 {
+    id: string;
+    strategies: Map<string, Map<string, StrategyV2[]>>;
+    authority: string[];
+}
+export interface StrategyV2 {
+    id: string;
+    vault_index: string;
+    signal_index: string;
+    user: string;
+    price_percentage: string;
+    size: string;
+    max_times: string;
+    target_rounds: string[];
+    receipts: TypusBidReceipt[];
+    active: boolean;
+    string_padding: string[];
+    bid_times: string;
+    bid_round: string;
+    bid_ts_ms: string;
+    bid_rounds: string[];
+    accumulated_profit: string;
+}
+export interface TypusBidReceipt {
+    id: string;
+    vid: string;
+    index: string;
+    metadata: string;
+    u64_padding: string[];
+}

package/lib/utils/auto-bid/view-function.js

@@ -0,0 +1,215 @@
+"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 };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVaults = exports.getUserStrategies = void 0;
+var bcs_1 = require("@mysten/bcs");
+var transactions_1 = require("@mysten/sui.js/transactions");
+var tools_1 = require("../tools");
+var bcs = new bcs_1.BCS((0, bcs_1.getSuiMoveConfig)());
+bcs.registerStructType("StrategyV2", {
+    id: "address",
+    vault_index: "u64",
+    signal_index: "u64",
+    user: "address",
+    price_percentage: "u64",
+    size: "u64",
+    max_times: "u64",
+    target_rounds: "vector<u64>",
+    receipts: "vector<TypusBidReceipt>",
+    active: "bool",
+    u64_padding: "vector<u64>",
+    bid_times: "u64",
+    bid_round: "u64",
+    bid_ts_ms: "u64",
+    bid_rounds: "vector<u64>",
+    accumulated_profit: "u64",
+    strategy_index: "u64",
+});
+// struct StrategyV2 has key, store {
+//     id: UID,
+//     vault_index: u64,
+//     signal_index: u64,
+//     user: address,
+//     // balance: Balance<B_TOKEN>,
+//     // profit: Balance<D_TOKEN>,
+//     price_percentage: u64,
+//     size: u64,
+//     max_times: u64,
+//     target_rounds: vector<u64>,
+//     receipts: vector<TypusBidReceipt>,
+//     active: bool,
+//     u64_padding: vector<u64>,
+//     // log
+//     bid_times: u64,
+//     bid_round: u64,
+//     bid_ts_ms: u64,
+//     bid_rounds: vector<u64>,
+//     accumulated_profit: u64,
+// }
+bcs.registerStructType("TypusBidReceipt", {
+    id: "address",
+    vid: "address",
+    index: "u64",
+    metadata: "String",
+    u64_padding: "vector<u64>",
+});
+function getUserStrategies(provider, packageId, strategyPool, user) {
+    return __awaiter(this, void 0, void 0, function () {
+        var transactionBlock, target, transactionBlockArguments, results, objBCS, reader, strategies;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    transactionBlock = new transactions_1.TransactionBlock();
+                    target = "".concat(packageId, "::auto_bid::get_user_strategies");
+                    transactionBlockArguments = [transactionBlock.pure(strategyPool), transactionBlock.pure(user)];
+                    transactionBlock.moveCall({
+                        target: target,
+                        typeArguments: [],
+                        arguments: transactionBlockArguments,
+                    });
+                    return [4 /*yield*/, provider.devInspectTransactionBlock({ transactionBlock: transactionBlock, sender: user })];
+                case 1:
+                    results = (_a.sent()).results;
+                    objBCS = results[0].returnValues[0][0];
+                    reader = new bcs_1.BcsReader(new Uint8Array(objBCS));
+                    strategies = [];
+                    reader.readVec(function (reader, i) {
+                        reader.read16();
+                        var strategy = {
+                            id: (0, tools_1.AddressFromBytes)(reader.readBytes(32)),
+                            vault_index: reader.read64(),
+                            signal_index: reader.read64(),
+                            user: (0, tools_1.AddressFromBytes)(reader.readBytes(32)),
+                            price_percentage: reader.read64(),
+                            size: reader.read64(),
+                            max_times: reader.read64(),
+                            target_rounds: reader.readVec(function (reader) {
+                                return reader.read64();
+                            }),
+                            receipts: reader.readVec(function (reader) {
+                                return {
+                                    id: (0, tools_1.AddressFromBytes)(reader.readBytes(32)),
+                                    vid: (0, tools_1.AddressFromBytes)(reader.readBytes(32)),
+                                    index: reader.read64(),
+                                    metadata: String.fromCharCode.apply(null, Array.from(reader.readBytes(reader.read8()))),
+                                    u64_padding: reader.readVec(function (reader) {
+                                        return reader.read64();
+                                    }),
+                                };
+                            }),
+                            active: reader.read8(),
+                            u64_padding: reader.readVec(function (reader) {
+                                return reader.read64();
+                            }),
+                            bid_times: reader.read64(),
+                            bid_round: reader.read64(),
+                            bid_ts_ms: reader.read64(),
+                            bid_rounds: reader.readVec(function (reader) {
+                                return reader.read64();
+                            }),
+                            accumulated_profit: reader.read64(),
+                            strategy_index: reader.read64(),
+                        };
+                        // console.log(strategy);
+                        strategies.push(strategy);
+                    });
+                    return [2 /*return*/, strategies];
+            }
+        });
+    });
+}
+exports.getUserStrategies = getUserStrategies;
+function getVaults(provider, strategyPool) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function () {
+        var pool, vaults, vaults_1, vaults_1_1, vault, signals, signals_1, signals_1_1, signal, strategyTable;
+        var e_1, _b, e_2, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0: return [4 /*yield*/, provider.getObject({ id: strategyPool, options: { showContent: true } })];
+                case 1:
+                    pool = (_a = (_d.sent()).data) === null || _a === void 0 ? void 0 : _a.content.fields;
+                    console.log(pool);
+                    vaults = pool.strategies.fields.contents;
+                    console.log(vaults);
+                    try {
+                        for (vaults_1 = __values(vaults), vaults_1_1 = vaults_1.next(); !vaults_1_1.done; vaults_1_1 = vaults_1.next()) {
+                            vault = vaults_1_1.value;
+                            signals = vault.fields.value.fields.contents;
+                            console.log(signals);
+                            try {
+                                for (signals_1 = (e_2 = void 0, __values(signals)), signals_1_1 = signals_1.next(); !signals_1_1.done; signals_1_1 = signals_1.next()) {
+                                    signal = signals_1_1.value;
+                                    strategyTable = signal.fields.value.fields.contents;
+                                    console.log(strategyTable);
+                                    // dynamic fields
+                                }
+                            }
+                            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                            finally {
+                                try {
+                                    if (signals_1_1 && !signals_1_1.done && (_c = signals_1.return)) _c.call(signals_1);
+                                }
+                                finally { if (e_2) throw e_2.error; }
+                            }
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (vaults_1_1 && !vaults_1_1.done && (_b = vaults_1.return)) _b.call(vaults_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.getVaults = getVaults;

package/lib/utils/nft-staking/authorized-entry.d.ts

@@ -1,3 +1,3 @@
 import { TransactionBlock } from "@mysten/sui.js/transactions";
-export declare function getSetProfitSharingTx(gasBudget: number, packageId: string, registry: string, level_profits: number[], amount: number): Promise<TransactionBlock>;
-export declare function getAllocateProfitSharingTx(gasBudget: number, packageId: string, registry: string, users: string[]): Promise<TransactionBlock>;
+export declare function getSetProfitSharingTx(gasBudget: number, packageId: string, registry: string, level_profits: number[], amount: number, coins: string[], typeArguments: string[], typeArgumentsRemove: string[]): Promise<TransactionBlock>;
+export declare function getAllocateProfitSharingTx(gasBudget: number, packageId: string, registry: string, users: string[], typeArguments: string[]): Promise<TransactionBlock>;

package/lib/utils/nft-staking/authorized-entry.js

@@ -54,31 +54,51 @@ var __read = (this && this.__read) || function (o, n) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAllocateProfitSharingTx = exports.getSetProfitSharingTx = void 0;
 var transactions_1 = require("@mysten/sui.js/transactions");
-function getSetProfitSharingTx(gasBudget, packageId, registry, level_profits, amount) {
+function getSetProfitSharingTx(gasBudget, packageId, registry, level_profits, amount, coins, typeArguments, typeArgumentsRemove) {
     return __awaiter(this, void 0, void 0, function () {
-        var tx, _a, coin;
-        return __generator(this, function (_b) {
+        var tx, _a, input_coin, coin, _b, input_coin;
+        return __generator(this, function (_c) {
             tx = new transactions_1.TransactionBlock();
-            _a = __read(tx.splitCoins(tx.gas, [tx.pure(amount)]), 1), coin = _a[0];
             tx.moveCall({
-                target: "".concat(packageId, "::tails_staking::set_profit_sharing"),
-                typeArguments: ["0x2::sui::SUI"],
-                arguments: [tx.object(registry), tx.pure(level_profits), coin],
+                target: "".concat(packageId, "::tails_staking::remove_profit_sharing"),
+                typeArguments: typeArgumentsRemove,
+                arguments: [tx.object(registry)],
             });
+            if (typeArguments[0] == "0x2::sui::SUI" ||
+                typeArguments[0] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI") {
+                _a = __read(tx.splitCoins(tx.gas, [tx.pure(amount)]), 1), input_coin = _a[0];
+                tx.moveCall({
+                    target: "".concat(packageId, "::tails_staking::set_profit_sharing"),
+                    typeArguments: typeArguments,
+                    arguments: [tx.object(registry), tx.pure(level_profits), input_coin],
+                });
+            }
+            else {
+                coin = coins.pop();
+                if (coins.length > 0) {
+                    tx.mergeCoins(tx.object(coin), coins.map(function (id) { return tx.object(id); }));
+                }
+                _b = __read(tx.splitCoins(tx.object(coin), [tx.pure(amount)]), 1), input_coin = _b[0];
+                tx.moveCall({
+                    target: "".concat(packageId, "::tails_staking::set_profit_sharing"),
+                    typeArguments: typeArguments,
+                    arguments: [tx.object(registry), tx.pure(level_profits), input_coin],
+                });
+            }
             tx.setGasBudget(gasBudget);
             return [2 /*return*/, tx];
         });
     });
 }
 exports.getSetProfitSharingTx = getSetProfitSharingTx;
-function getAllocateProfitSharingTx(gasBudget, packageId, registry, users) {
+function getAllocateProfitSharingTx(gasBudget, packageId, registry, users, typeArguments) {
     return __awaiter(this, void 0, void 0, function () {
         var tx;
         return __generator(this, function (_a) {
             tx = new transactions_1.TransactionBlock();
             tx.moveCall({
                 target: "".concat(packageId, "::tails_staking::allocate_profit_sharing"),
-                typeArguments: ["0x2::sui::SUI"],
+                typeArguments: typeArguments,
                 arguments: [tx.object(registry), tx.pure(users)],
             });
             tx.setGasBudget(gasBudget);

package/lib/utils/nft-staking/user-entry.d.ts

@@ -23,7 +23,7 @@ export declare function getTransferNftsTx(gasBudget: number, nftPackageId: strin
     )
 */
 export declare function getStakeNftTx(gasBudget: number, nftPackageId: string, registry: string, kiosk: string, kiosk_cap: string, nft_id: string): Promise<TransactionBlock>;
-export declare function getSwitchNftTx(gasBudget: number, nftPackageId: string, registry: string, kiosk: string, kiosk_cap: string, nft_id: string): Promise<TransactionBlock>;
+export declare function getSwitchNftTx(gasBudget: number, nftPackageId: string, registry: string, kiosk: string, kiosk_cap: string, nft_id: string, typeArguments: string[]): Promise<TransactionBlock>;
 export declare function getCreateKioskAndLockNftTx(kioskClient: KioskClient, gasBudget: number, nftPackageId: string, policy: string, nft_id: string, singer: string): Promise<TransactionBlock>;
 /**
     public fun unstake_nft(
@@ -34,7 +34,7 @@ export declare function getCreateKioskAndLockNftTx(kioskClient: KioskClient, gas
         ctx: &mut TxContext
     )
 */
-export declare function getUnstakeNftTx(gasBudget: number, nftPackageId: string, registry: string, kiosk: string, kiosk_cap: string): Promise<TransactionBlock>;
+export declare function getUnstakeNftTx(gasBudget: number, nftPackageId: string, registry: string, kiosk: string, kiosk_cap: string, typeArguments: string[]): Promise<TransactionBlock>;
 /**
     public fun daily_attend(
         registry: &mut Registry,
@@ -83,4 +83,4 @@ export declare function consumeExpCoinUnstakedTx(gasBudget: number, nftPackageId
     )
 */
 export declare function consumeExpCoinStakedTx(gasBudget: number, nftPackageId: string, typeArguments: string[], registry: string, exp_coins: string[], amount: string): Promise<TransactionBlock>;
-export declare function getClaimProfitSharingTx(gasBudget: number, packageId: string, registry: string): Promise<TransactionBlock>;
+export declare function getClaimProfitSharingTx(gasBudget: number, packageId: string, registry: string, typeArguments: string[]): Promise<TransactionBlock>;

package/lib/utils/nft-staking/user-entry.js

@@ -131,7 +131,7 @@ function getStakeNftTx(gasBudget, nftPackageId, registry, kiosk, kiosk_cap, nft_
     });
 }
 exports.getStakeNftTx = getStakeNftTx;
-function getSwitchNftTx(gasBudget, nftPackageId, registry, kiosk, kiosk_cap, nft_id) {
+function getSwitchNftTx(gasBudget, nftPackageId, registry, kiosk, kiosk_cap, nft_id, typeArguments) {
     return __awaiter(this, void 0, void 0, function () {
         var tx, _a, coin;
         return __generator(this, function (_b) {
@@ -144,7 +144,7 @@ function getSwitchNftTx(gasBudget, nftPackageId, registry, kiosk, kiosk_cap, nft
             });
             tx.moveCall({
                 target: "".concat(nftPackageId, "::tails_staking::claim_profit_sharing"),
-                typeArguments: ["0x2::sui::SUI"],
+                typeArguments: typeArguments,
                 arguments: [tx.object(registry)],
             });
             tx.moveCall({
@@ -193,7 +193,7 @@ exports.getCreateKioskAndLockNftTx = getCreateKioskAndLockNftTx;
         ctx: &mut TxContext
     )
 */
-function getUnstakeNftTx(gasBudget, nftPackageId, registry, kiosk, kiosk_cap) {
+function getUnstakeNftTx(gasBudget, nftPackageId, registry, kiosk, kiosk_cap, typeArguments) {
     return __awaiter(this, void 0, void 0, function () {
         var tx;
         return __generator(this, function (_a) {
@@ -205,7 +205,7 @@ function getUnstakeNftTx(gasBudget, nftPackageId, registry, kiosk, kiosk_cap) {
             });
             tx.moveCall({
                 target: "".concat(nftPackageId, "::tails_staking::claim_profit_sharing"),
-                typeArguments: ["0x2::sui::SUI"],
+                typeArguments: typeArguments,
                 arguments: [tx.object(registry)],
             });
             tx.moveCall({
@@ -495,14 +495,14 @@ function consumeExpCoinStakedTx(gasBudget, nftPackageId, typeArguments, registry
     });
 }
 exports.consumeExpCoinStakedTx = consumeExpCoinStakedTx;
-function getClaimProfitSharingTx(gasBudget, packageId, registry) {
+function getClaimProfitSharingTx(gasBudget, packageId, registry, typeArguments) {
     return __awaiter(this, void 0, void 0, function () {
         var tx;
         return __generator(this, function (_a) {
             tx = new transactions_1.TransactionBlock();
             tx.moveCall({
                 target: "".concat(packageId, "::tails_staking::claim_profit_sharing"),
-                typeArguments: ["0x2::sui::SUI"],
+                typeArguments: typeArguments,
                 arguments: [tx.object(registry)],
             });
             tx.setGasBudget(gasBudget);

package/lib/utils/tails-exp-dice/fetch.d.ts

@@ -54,6 +54,7 @@ export interface ProfitSharing {
     pool: string;
     remaining: string;
     total: string;
+    tokenType: string;
 }
 export declare function getProfitSharing(provider: SuiClient, diceProfitSharing: string): Promise<ProfitSharing>;
 export declare function calculateLevelReward(totalRewards: number, levelShares: number[], numOfHolders: number[]): number[];

package/lib/utils/tails-exp-dice/fetch.js

@@ -246,18 +246,21 @@ function getLeaderBoard(drawDisplays) {
 }
 exports.getLeaderBoard = getLeaderBoard;
 function getProfitSharing(provider, diceProfitSharing) {
-    var _a, _b;
+    var _a, _b, _c, _d;
     return __awaiter(this, void 0, void 0, function () {
-        var object, result;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
+        var object, type, tokenType, result;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
                 case 0: return [4 /*yield*/, provider.getObject({
                         id: diceProfitSharing,
                         options: { showContent: true },
                     })];
                 case 1:
-                    object = _c.sent();
-                    result = (_b = (_a = object.data) === null || _a === void 0 ? void 0 : _a.content) === null || _b === void 0 ? void 0 : _b.fields.value.fields;
+                    object = _e.sent();
+                    type = (_a = object.data) === null || _a === void 0 ? void 0 : _a.content.type;
+                    tokenType = (_b = type.split("<").at(-1)) === null || _b === void 0 ? void 0 : _b.replace(">>", "");
+                    result = (_d = (_c = object.data) === null || _c === void 0 ? void 0 : _c.content) === null || _d === void 0 ? void 0 : _d.fields.value.fields;
+                    result.tokenType = tokenType;
                     return [2 /*return*/, result];
             }
         });

package/lib/utils/token.js

@@ -24,6 +24,10 @@ function typeArgToAsset(typeArg) {
             return "TURBOS";
         case "0x3a5143bb1196e3bcdfab6203d1683ae29edd26294fc8bfeafe4aaa9d2704df37":
             return "APT";
+        case "0x76cb819b01abed502bee8a702b4c2d547532c12f25001c9dea795a5e631c26f1":
+            return "FUD";
+        case "0xf325ce1300e8dac124071d3152c5c5ee6174914f8bc2161e88329cf579246efc":
+            return "AFSUI";
         default:
             if (typeArgs[2] == "BTC") {
                 return "WBTC";

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

@@ -64,6 +64,7 @@ export interface UpdateConfigRequests {
         capacity?: string;
         leverage?: string;
         riskLevel?: string;
+        depositIncentiveBpDivisorDecimal?: string;
     };
 }
 export declare function getUpdateConfigTx(gasBudget: number, packageId: string, registry: string, requests: UpdateConfigRequests[]): Promise<TransactionBlock>;

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

@@ -156,6 +156,7 @@ function getUpdateConfigTx(gasBudget, packageId, registry, requests) {
                         tx.pure(request.config.capacity ? [request.config.capacity] : []),
                         tx.pure(request.config.leverage ? [request.config.leverage] : []),
                         tx.pure(request.config.riskLevel ? [request.config.riskLevel] : []),
+                        tx.pure(request.config.depositIncentiveBpDivisorDecimal ? [request.config.depositIncentiveBpDivisorDecimal] : []),
                     ],
                 });
             });