@typus/typus-sdk 1.2.64 → 1.2.66-tgld

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

@@ -66,36 +66,91 @@ var kiosk_1 = require("@mysten/kiosk");
         ctx: &mut TxContext
     )
 */
-function getTransferNftTx(gasBudget, nftPackageId, registry, kiosk, kiosk_cap, nft_id, receiver) {
+function getTransferNftTx(gasBudget, nftPackageId, registry, personalKioskPackageId, tails_id, receiver) {
     return __awaiter(this, void 0, void 0, function () {
-        var tx, _a, coin;
-        return __generator(this, function (_b) {
+        var tx, _a, coin, _b, personalKioskCap, borrow;
+        return __generator(this, function (_c) {
             tx = new transactions_1.TransactionBlock();
             _a = __read(tx.splitCoins(tx.gas, [tx.pure(10000000)]), 1), coin = _a[0];
-            tx.moveCall({
-                target: "".concat(nftPackageId, "::tails_staking::transfer_nft"),
-                typeArguments: [],
-                arguments: [tx.object(registry), tx.object(kiosk), tx.object(kiosk_cap), tx.pure(nft_id), tx.pure(receiver), coin],
-            });
+            if (tails_id.isPersonal) {
+                _b = __read(tx.moveCall({
+                    target: "".concat(personalKioskPackageId, "::personal_kiosk::borrow_val"),
+                    arguments: [tx.object(tails_id.kioskCap)],
+                }), 2), personalKioskCap = _b[0], borrow = _b[1];
+                tx.moveCall({
+                    target: "".concat(nftPackageId, "::tails_staking::transfer_nft"),
+                    typeArguments: [],
+                    arguments: [tx.object(registry), tx.object(tails_id.kiosk), personalKioskCap, tx.pure(tails_id.nftId), tx.pure(receiver), coin],
+                });
+                tx.moveCall({
+                    target: "".concat(personalKioskPackageId, "::personal_kiosk::return_val"),
+                    arguments: [tx.object(tails_id.kioskCap), personalKioskCap, borrow],
+                });
+            }
+            else {
+                tx.moveCall({
+                    target: "".concat(nftPackageId, "::tails_staking::transfer_nft"),
+                    typeArguments: [],
+                    arguments: [
+                        tx.object(registry),
+                        tx.object(tails_id.kiosk),
+                        tx.object(tails_id.kioskCap),
+                        tx.pure(tails_id.nftId),
+                        tx.pure(receiver),
+                        coin,
+                    ],
+                });
+            }
             tx.setGasBudget(gasBudget);
             return [2 /*return*/, tx];
         });
     });
 }
 exports.getTransferNftTx = getTransferNftTx;
-function getTransferNftsTx(gasBudget, nftPackageId, registry, kiosks, kiosk_caps, nft_ids, receiver) {
+function getTransferNftsTx(gasBudget, nftPackageId, personalKioskPackageId, registry, tailsIds, receiver) {
     return __awaiter(this, void 0, void 0, function () {
-        var tx, i, _a, coin;
-        return __generator(this, function (_b) {
+        var tx, i, _a, coin, _b, personalKioskCap, borrow;
+        return __generator(this, function (_c) {
             tx = new transactions_1.TransactionBlock();
             i = 0;
-            while (i < kiosks.length) {
+            while (i < tailsIds.length) {
                 _a = __read(tx.splitCoins(tx.gas, [tx.pure(10000000)]), 1), coin = _a[0];
-                tx.moveCall({
-                    target: "".concat(nftPackageId, "::tails_staking::transfer_nft"),
-                    typeArguments: [],
-                    arguments: [tx.object(registry), tx.object(kiosks[i]), tx.object(kiosk_caps[i]), tx.pure(nft_ids[i]), tx.pure(receiver), coin],
-                });
+                if (tailsIds[i].isPersonal) {
+                    _b = __read(tx.moveCall({
+                        target: "".concat(personalKioskPackageId, "::personal_kiosk::borrow_val"),
+                        arguments: [tx.object(tailsIds[i].kioskCap)],
+                    }), 2), personalKioskCap = _b[0], borrow = _b[1];
+                    tx.moveCall({
+                        target: "".concat(nftPackageId, "::tails_staking::transfer_nft"),
+                        typeArguments: [],
+                        arguments: [
+                            tx.object(registry),
+                            tx.object(tailsIds[i].kiosk),
+                            personalKioskCap,
+                            tx.pure(tailsIds[i].nftId),
+                            tx.pure(receiver),
+                            coin,
+                        ],
+                    });
+                    tx.moveCall({
+                        target: "".concat(personalKioskPackageId, "::personal_kiosk::return_val"),
+                        arguments: [tx.object(tailsIds[i].kioskCap), personalKioskCap, borrow],
+                    });
+                }
+                else {
+                    tx.moveCall({
+                        target: "".concat(nftPackageId, "::tails_staking::transfer_nft"),
+                        typeArguments: [],
+                        arguments: [
+                            tx.object(registry),
+                            tx.object(tailsIds[i].kiosk),
+                            tx.object(tailsIds[i].kioskCap),
+                            tx.pure(tailsIds[i].nftId),
+                            tx.pure(receiver),
+                            coin,
+                        ],
+                    });
+                }
                 i += 1;
             }
             tx.setGasBudget(gasBudget);
@@ -114,27 +169,51 @@ exports.getTransferNftsTx = getTransferNftsTx;
         ctx: &mut TxContext
     )
 */
-function getStakeNftTx(gasBudget, nftPackageId, registry, kiosk, kiosk_cap, nft_id) {
+function getStakeNftTx(gasBudget, nftPackageId, registry, personalKioskPackageId, tails_id) {
     return __awaiter(this, void 0, void 0, function () {
-        var tx, _a, coin;
-        return __generator(this, function (_b) {
+        var tx, _a, coin, _b, personalKioskCap, borrow;
+        return __generator(this, function (_c) {
             tx = new transactions_1.TransactionBlock();
             _a = __read(tx.splitCoins(tx.gas, [tx.pure(50000000)]), 1), coin = _a[0];
-            tx.moveCall({
-                target: "".concat(nftPackageId, "::tails_staking::stake_nft"),
-                typeArguments: [],
-                arguments: [tx.object(registry), tx.object(kiosk), tx.object(kiosk_cap), tx.pure(nft_id), tx.object(constants_1.CLOCK), coin],
-            });
+            if (tails_id.isPersonal) {
+                _b = __read(tx.moveCall({
+                    target: "".concat(personalKioskPackageId, "::personal_kiosk::borrow_val"),
+                    arguments: [tx.object(tails_id.kioskCap)],
+                }), 2), personalKioskCap = _b[0], borrow = _b[1];
+                tx.moveCall({
+                    target: "".concat(nftPackageId, "::tails_staking::stake_nft"),
+                    typeArguments: [],
+                    arguments: [tx.object(registry), tx.object(tails_id.kiosk), personalKioskCap, tx.pure(tails_id.nftId), tx.object(constants_1.CLOCK), coin],
+                });
+                tx.moveCall({
+                    target: "".concat(personalKioskPackageId, "::personal_kiosk::return_val"),
+                    arguments: [tx.object(tails_id.kioskCap), personalKioskCap, borrow],
+                });
+            }
+            else {
+                tx.moveCall({
+                    target: "".concat(nftPackageId, "::tails_staking::stake_nft"),
+                    typeArguments: [],
+                    arguments: [
+                        tx.object(registry),
+                        tx.object(tails_id.kiosk),
+                        tx.object(tails_id.kioskCap),
+                        tx.pure(tails_id.nftId),
+                        tx.object(constants_1.CLOCK),
+                        coin,
+                    ],
+                });
+            }
             tx.setGasBudget(gasBudget);
             return [2 /*return*/, tx];
         });
     });
 }
 exports.getStakeNftTx = getStakeNftTx;
-function getSwitchNftTx(gasBudget, nftPackageId, registry, kiosk, kiosk_cap, nft_id, typeArguments) {
+function getSwitchNftTx(gasBudget, nftPackageId, registry, personalKioskPackageId, tails_id, typeArguments) {
     return __awaiter(this, void 0, void 0, function () {
-        var tx, _a, coin;
-        return __generator(this, function (_b) {
+        var tx, _a, coin, _b, personalKioskCap, borrow;
+        return __generator(this, function (_c) {
             tx = new transactions_1.TransactionBlock();
             _a = __read(tx.splitCoins(tx.gas, [tx.pure(50000000)]), 1), coin = _a[0];
             tx.moveCall({
@@ -152,11 +231,35 @@ function getSwitchNftTx(gasBudget, nftPackageId, registry, kiosk, kiosk_cap, nft
                 typeArguments: typeArguments,
                 arguments: [tx.object(registry), tx.pure("exp_profit")],
             });
-            tx.moveCall({
-                target: "".concat(nftPackageId, "::tails_staking::switch_nft"),
-                typeArguments: [],
-                arguments: [tx.object(registry), tx.object(kiosk), tx.object(kiosk_cap), tx.pure(nft_id), tx.object(constants_1.CLOCK), coin],
-            });
+            if (tails_id.isPersonal) {
+                _b = __read(tx.moveCall({
+                    target: "".concat(personalKioskPackageId, "::personal_kiosk::borrow_val"),
+                    arguments: [tx.object(tails_id.kioskCap)],
+                }), 2), personalKioskCap = _b[0], borrow = _b[1];
+                tx.moveCall({
+                    target: "".concat(nftPackageId, "::tails_staking::switch_nft"),
+                    typeArguments: [],
+                    arguments: [tx.object(registry), tx.object(tails_id.kiosk), personalKioskCap, tx.pure(tails_id.nftId), tx.object(constants_1.CLOCK), coin],
+                });
+                tx.moveCall({
+                    target: "".concat(personalKioskPackageId, "::personal_kiosk::return_val"),
+                    arguments: [tx.object(tails_id.kioskCap), personalKioskCap, borrow],
+                });
+            }
+            else {
+                tx.moveCall({
+                    target: "".concat(nftPackageId, "::tails_staking::switch_nft"),
+                    typeArguments: [],
+                    arguments: [
+                        tx.object(registry),
+                        tx.object(tails_id.kiosk),
+                        tx.object(tails_id.kioskCap),
+                        tx.pure(tails_id.nftId),
+                        tx.object(constants_1.CLOCK),
+                        coin,
+                    ],
+                });
+            }
             tx.setGasBudget(gasBudget);
             return [2 /*return*/, tx];
         });
@@ -457,21 +560,38 @@ exports.getLevelUpTx = getLevelUpTx;
         ctx: &mut TxContext
     )
 */
-function consumeExpCoinUnstakedTx(gasBudget, nftPackageId, typeArguments, registry, kiosk, kiosk_cap, nft_id, exp_coins, amount) {
+function consumeExpCoinUnstakedTx(gasBudget, nftPackageId, typeArguments, registry, personalKioskPackageId, tails_id, exp_coins, amount) {
     return __awaiter(this, void 0, void 0, function () {
-        var tx, coin, _a, input_coin;
-        return __generator(this, function (_b) {
+        var tx, coin, _a, input_coin, _b, personalKioskCap, borrow;
+        return __generator(this, function (_c) {
             tx = new transactions_1.TransactionBlock();
             coin = exp_coins.pop();
             if (exp_coins.length > 0) {
                 tx.mergeCoins(tx.object(coin), exp_coins.map(function (id) { return tx.object(id); }));
             }
             _a = __read(tx.splitCoins(tx.object(coin), [tx.pure(amount)]), 1), input_coin = _a[0];
-            tx.moveCall({
-                target: "".concat(nftPackageId, "::tails_staking::consume_exp_coin_unstaked"),
-                typeArguments: typeArguments,
-                arguments: [tx.object(registry), tx.object(kiosk), tx.object(kiosk_cap), tx.pure(nft_id), input_coin],
-            });
+            if (tails_id.isPersonal) {
+                _b = __read(tx.moveCall({
+                    target: "".concat(personalKioskPackageId, "::personal_kiosk::borrow_val"),
+                    arguments: [tx.object(tails_id.kioskCap)],
+                }), 2), personalKioskCap = _b[0], borrow = _b[1];
+                tx.moveCall({
+                    target: "".concat(nftPackageId, "::tails_staking::consume_exp_coin_unstaked"),
+                    typeArguments: typeArguments,
+                    arguments: [tx.object(registry), tx.object(tails_id.kiosk), personalKioskCap, tx.pure(tails_id.nftId), input_coin],
+                });
+                tx.moveCall({
+                    target: "".concat(personalKioskPackageId, "::personal_kiosk::return_val"),
+                    arguments: [tx.object(tails_id.kioskCap), personalKioskCap, borrow],
+                });
+            }
+            else {
+                tx.moveCall({
+                    target: "".concat(nftPackageId, "::tails_staking::consume_exp_coin_unstaked"),
+                    typeArguments: typeArguments,
+                    arguments: [tx.object(registry), tx.object(tails_id.kiosk), tx.object(tails_id.kioskCap), tx.pure(tails_id.nftId), input_coin],
+                });
+            }
             tx.setGasBudget(gasBudget);
             return [2 /*return*/, tx];
         });

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

@@ -94,6 +94,10 @@ export declare function getRedeemTx(input: {
 }): TransactionBlock;
 export declare function getNewBidTx(input: {
     tx: TransactionBlock;
+    typusEcosystemVersion: string;
+    typusUserRegistry: string;
+    tgldRegistry: string;
+    typusLeaderboardRegistry: string;
     typusFrameworkPackageId: string;
     typusDovSinglePackageId: string;
     typusDovSingleRegistry: string;

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

@@ -308,9 +308,13 @@ function getNewBidTx(input) {
         ],
     });
     var result = input.tx.moveCall({
-        target: "".concat(input.typusDovSinglePackageId, "::tails_staking::new_bid_v2"),
+        target: "".concat(input.typusDovSinglePackageId, "::tails_staking::bid"),
         typeArguments: input.typeArguments,
         arguments: [
+            input.tx.object(input.typusEcosystemVersion),
+            input.tx.object(input.typusUserRegistry),
+            input.tx.object(input.tgldRegistry),
+            input.tx.object(input.typusLeaderboardRegistry),
             input.tx.object(input.typusDovSingleRegistry),
             input.tx.pure(input.index),
             input.tx.makeMoveVec({ objects: [mfud] }),

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

@@ -173,6 +173,10 @@ export declare function getWithdrawHarvestClaimTx(input: {
 */
 export declare function getNewBidTx(input: {
     tx: TransactionBlock;
+    typusEcosystemVersion: string;
+    typusUserRegistry: string;
+    tgldRegistry: string;
+    typusLeaderboardRegistry: string;
     typusFrameworkPackageId: string;
     typusDovSinglePackageId: string;
     typusDovSingleRegistry: string;

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

@@ -442,9 +442,13 @@ function getNewBidTx(input) {
             input.typeArguments[1] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI")) {
         var _a = __read(input.tx.splitCoins(input.tx.gas, [input.tx.pure(input.premium_required)]), 1), coin = _a[0];
         var result = input.tx.moveCall({
-            target: "".concat(input.typusDovSinglePackageId, "::tails_staking::new_bid_v2"),
+            target: "".concat(input.typusDovSinglePackageId, "::tails_staking::bid"),
             typeArguments: input.typeArguments,
             arguments: [
+                input.tx.object(input.typusEcosystemVersion),
+                input.tx.object(input.typusUserRegistry),
+                input.tx.object(input.tgldRegistry),
+                input.tx.object(input.typusLeaderboardRegistry),
                 input.tx.object(input.typusDovSingleRegistry),
                 input.tx.pure(input.index),
                 input.tx.makeMoveVec({ objects: [coin] }),
@@ -474,9 +478,13 @@ function getNewBidTx(input) {
             arguments: [input.tx.object(balance)],
         });
         var result = input.tx.moveCall({
-            target: "".concat(input.typusDovSinglePackageId, "::tails_staking::new_bid_v2"),
+            target: "".concat(input.typusDovSinglePackageId, "::tails_staking::bid"),
             typeArguments: input.typeArguments,
             arguments: [
+                input.tx.object(input.typusEcosystemVersion),
+                input.tx.object(input.typusUserRegistry),
+                input.tx.object(input.tgldRegistry),
+                input.tx.object(input.typusLeaderboardRegistry),
                 input.tx.object(input.typusDovSingleRegistry),
                 input.tx.pure(input.index),
                 input.tx.makeMoveVec({ objects: [coin] }),

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

@@ -149,7 +149,7 @@ function parseTxHistory(datas, originPackage, vaults) {
                         }
                     })
                         .reduce(function (promise, event) { return __awaiter(_this, void 0, void 0, function () {
-                        var txHistory, functionType, action, Action, Amount, Index, Period, Vault, RiskLevel, Tails, Exp, d_token, b_token, o_token, i, i, token, amount, deposit_amount, deposit_amount, balance, balance, profit, profit, token, amount, amount, token, amount, size, token, amount, token, amount, size, bidder_balance;
+                        var txHistory, functionType, action, Action, Amount, Index, Period, Vault, RiskLevel, Tails, Exp, d_token, b_token, o_token, i, i, i, token, amount, deposit_amount, deposit_amount, balance, balance, profit, profit, token, amount, amount, token, amount, size, token, amount, token, amount, size, bidder_balance;
                         var _a;
                         var _b;
                         return __generator(this, function (_c) {
@@ -196,9 +196,11 @@ function parseTxHistory(datas, originPackage, vaults) {
                                             Tails = "#".concat(event.parsedJson.number);
                                             break;
                                         case "DailyAttendEvent":
-                                            Action = "Check In";
-                                            Tails = "#".concat(event.parsedJson.number);
-                                            Exp = "10";
+                                            i = txHistory.findIndex(function (x) { return x.txDigest == event.id.txDigest && x.Action == "Collect EXP"; });
+                                            if (i != -1) {
+                                                txHistory[i].Action = "Check In";
+                                                return [2 /*return*/, txHistory];
+                                            }
                                             break;
                                         case "FirstDepositEvent":
                                             Action = "First Deposit";
@@ -274,7 +276,7 @@ function parseTxHistory(datas, originPackage, vaults) {
                                         case "RedeemEvent":
                                             token = (0, token_1.typeArgToAsset)("0x" + event.parsedJson.token.name);
                                             amount = Number(event.parsedJson.amount) / Math.pow(10, (0, token_1.assetToDecimal)(token));
-                                            Action = "Harvest";
+                                            Action = "Harvest Reward";
                                             Amount = "".concat((0, bignumber_js_1.default)(amount).toFixed(), " ").concat(token);
                                             Index = Index;
                                             break;
@@ -302,10 +304,25 @@ function parseTxHistory(datas, originPackage, vaults) {
                                             Action = "Rebate";
                                             Amount = "".concat((0, bignumber_js_1.default)(amount).toFixed(), " ").concat(token);
                                             break;
-                                        case "ClaimProfitSharingEvent":
+                                        // case "ClaimProfitSharingEvent":
+                                        //     var token = typeArgToAsset("0x" + event.parsedJson!.token.name);
+                                        //     var amount = Number(event.parsedJson!.value) / 10 ** assetToDecimal(token)!;
+                                        //     Action = "Claim Profit Sharing";
+                                        //     Amount = `${BigNumber(amount).toFixed()} ${token}`;
+                                        //     Tails = `#${event.parsedJson!.number}`;
+                                        //     break;
+                                        case "ClaimProfitSharingEventV2":
                                             token = (0, token_1.typeArgToAsset)("0x" + event.parsedJson.token.name);
                                             amount = Number(event.parsedJson.value) / Math.pow(10, (0, token_1.assetToDecimal)(token));
-                                            Action = "Claim Profit Sharing";
+                                            // dice_profit, exp_profit
+                                            switch (event.parsedJson.name) {
+                                                case "dice_profit":
+                                                    Action = "Harvest Dice Profit";
+                                                    break;
+                                                case "exp_profit":
+                                                    Action = "Harvest Leaderboard Prize";
+                                                    break;
+                                            }
                                             Amount = "".concat((0, bignumber_js_1.default)(amount).toFixed(), " ").concat(token);
                                             Tails = "#".concat(event.parsedJson.number);
                                             break;

package/lib/utils/typus-nft/fetch.d.ts

@@ -1,4 +1,4 @@
-import { SuiClient } from "@mysten/sui.js/client";
+import { SuiClient, SuiObjectResponse } from "@mysten/sui.js/client";
 import { KioskClient } from "@mysten/kiosk";
 export declare function getPool(provider: SuiClient, pool: string): Promise<PoolData>;
 export interface PoolData {
@@ -12,16 +12,19 @@ export interface PoolData {
 export declare const necklaces: string[];
 export declare function getPoolMap(provider: SuiClient, nftConfig: any): Promise<Map<string, PoolData>>;
 export declare function getWhitelistMap(nftConfig: any, wlTokens: any): Promise<Map<string, string[]>>;
-interface TailsId {
+export interface TailsId {
     nftId: string;
     kiosk: string;
     kioskCap: string;
     tails: Tails;
+    isPersonal: boolean;
 }
 export interface kioskOwnerCap {
-    objectId: string;
     kioskId: string;
+    objectId: string;
+    isPersonal: boolean;
 }
+export declare function getkioskOwnerCaps(datas: SuiObjectResponse[]): kioskOwnerCap[];
 export declare function getTailsIds(kioskClient: KioskClient, nftConfig: any, kioskOwnerCaps: kioskOwnerCap[]): Promise<TailsId[]>;
 export interface TailsWithType extends Tails {
     type: string | null | undefined;
@@ -62,5 +65,4 @@ export interface DiscountPoolData {
     balance: string;
     inventory: number;
 }
-export declare function getMintHistory(provider: SuiClient, NFT_PACKAGE_UPGRADE: string, vrf_input: any): Promise<import("@mysten/sui.js/client").PaginatedEvents | undefined>;
-export {};
+export declare function getMintHistory(provider: SuiClient, NFT_PACKAGE: string, vrf_input: any): Promise<import("@mysten/sui.js/client").PaginatedEvents | undefined>;