@typus/typus-sdk 1.2.15 → 1.2.17

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

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

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

@@ -52,18 +52,13 @@ var __read = (this && this.__read) || function (o, n) {
     return ar;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAllocateProfitSharingTx = exports.getSetProfitSharingTx = void 0;
+exports.getRemoveProfitSharingTx = exports.getAllocateProfitSharingTx = exports.getSetProfitSharingTx = void 0;
 var transactions_1 = require("@mysten/sui.js/transactions");
-function getSetProfitSharingTx(gasBudget, packageId, registry, level_profits, amount, coins, typeArguments, typeArgumentsRemove) {
+function getSetProfitSharingTx(gasBudget, packageId, registry, level_profits, amount, coins, typeArguments) {
     return __awaiter(this, void 0, void 0, function () {
         var tx, _a, input_coin, coin, _b, input_coin;
         return __generator(this, function (_c) {
             tx = new transactions_1.TransactionBlock();
-            tx.moveCall({
-                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];
@@ -107,3 +102,19 @@ function getAllocateProfitSharingTx(gasBudget, packageId, registry, users, typeA
     });
 }
 exports.getAllocateProfitSharingTx = getAllocateProfitSharingTx;
+function getRemoveProfitSharingTx(gasBudget, packageId, registry, typeArgumentsRemove) {
+    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::remove_profit_sharing"),
+                typeArguments: typeArgumentsRemove,
+                arguments: [tx.object(registry)],
+            });
+            tx.setGasBudget(gasBudget);
+            return [2 /*return*/, tx];
+        });
+    });
+}
+exports.getRemoveProfitSharingTx = getRemoveProfitSharingTx;

package/lib/utils/token.js

@@ -78,6 +78,8 @@ function assetToDecimal(asset) {
             return 8;
         case "BUCK":
             return 9;
+        case "AFSUI":
+            return 9;
     }
 }
 exports.assetToDecimal = assetToDecimal;

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

@@ -41,12 +41,16 @@ export declare function getUnsubscribeTx(input: {
 export declare function getCompoundTx(input: {
     tx: TransactionBlock;
     typusFrameworkOriginPackageId: string;
+    typusFrameworkPackageId: string;
     typusDovSinglePackageId: string;
     typusDovSingleRegistry: string;
+    mfudPackageId: string;
+    mfudRegistry: string;
     typeArguments: string[];
     index: string;
     receipts: string[] | TransactionObjectArgument[];
     user: string;
+    incentiveToken?: string;
 }): TransactionBlock;
 export declare function getClaimTx(input: {
     tx: TransactionBlock;
@@ -73,6 +77,7 @@ export declare function getHarvestTx(input: {
     index: string;
     receipts: string[] | TransactionObjectArgument[];
     user: string;
+    incentiveToken?: string;
 }): TransactionBlock;
 export declare function getRedeemTx(input: {
     tx: TransactionBlock;

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRebateTx = exports.getExerciseTx = exports.getNewBidTx = exports.getRedeemTx = exports.getHarvestTx = exports.getClaimTx = exports.getCompoundTx = exports.getUnsubscribeTx = exports.getWithdrawTx = exports.getDepositTx = void 0;
 var constants_1 = require("../../constants");
+var user_entry_1 = require("./user-entry");
 function getDepositTx(input) {
     var mfud = input.tx.moveCall({
         target: "".concat(input.mfudPackageId, "::mfud::mint"),
@@ -100,7 +101,50 @@ function getCompoundTx(input) {
             input.tx.object(constants_1.CLOCK),
         ],
     });
-    input.tx.transferObjects([input.tx.object(result[0])], input.user);
+    if (input.incentiveToken) {
+        input.typeArguments.push(input.incentiveToken);
+        if (input.incentiveToken == "".concat(input.mfudPackageId, "::mfud::MFUD")) {
+            var receipt = input.tx.moveCall({
+                target: "0x1::option::destroy_some",
+                typeArguments: ["".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt")],
+                arguments: [input.tx.object(result[1])],
+            });
+            input.tx = getRedeemTx({
+                tx: input.tx,
+                typusFrameworkOriginPackageId: input.typusFrameworkOriginPackageId,
+                typusFrameworkPackageId: input.typusFrameworkPackageId,
+                typusDovSinglePackageId: input.typusDovSinglePackageId,
+                typusDovSingleRegistry: input.typusDovSingleRegistry,
+                mfudPackageId: input.mfudPackageId,
+                mfudRegistry: input.mfudRegistry,
+                typeArguments: input.typeArguments,
+                index: input.index,
+                receipts: [input.tx.object(receipt)],
+                user: input.user,
+            });
+        }
+        else {
+            var receipt = input.tx.moveCall({
+                target: "0x1::option::destroy_some",
+                typeArguments: ["".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt")],
+                arguments: [input.tx.object(result[1])],
+            });
+            input.tx = (0, user_entry_1.getRedeemTx)({
+                tx: input.tx,
+                typusFrameworkOriginPackageId: input.typusFrameworkOriginPackageId,
+                typusFrameworkPackageId: input.typusFrameworkPackageId,
+                typusDovSinglePackageId: input.typusDovSinglePackageId,
+                typusDovSingleRegistry: input.typusDovSingleRegistry,
+                typeArguments: input.typeArguments,
+                index: input.index,
+                receipts: [input.tx.object(receipt)],
+                user: input.user,
+            });
+        }
+    }
+    else {
+        input.tx.transferObjects([input.tx.object(result[0])], input.user);
+    }
     return input.tx;
 }
 exports.getCompoundTx = getCompoundTx;
@@ -157,10 +201,53 @@ function getHarvestTx(input) {
         arguments: [input.tx.object(input.mfudRegistry), input.tx.object(mfud_coin)],
     });
     input.tx.transferObjects([input.tx.object(fud_coin)], input.user);
-    input.tx.moveCall({
-        target: "".concat(input.typusFrameworkPackageId, "::vault::transfer_deposit_receipt"),
-        arguments: [input.tx.object(result[1]), input.tx.pure(input.user)],
-    });
+    if (input.incentiveToken) {
+        input.typeArguments.push(input.incentiveToken);
+        if (input.incentiveToken == "".concat(input.mfudPackageId, "::mfud::MFUD")) {
+            var receipt = input.tx.moveCall({
+                target: "0x1::option::destroy_some",
+                typeArguments: ["".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt")],
+                arguments: [input.tx.object(result[1])],
+            });
+            input.tx = getRedeemTx({
+                tx: input.tx,
+                typusFrameworkOriginPackageId: input.typusFrameworkOriginPackageId,
+                typusFrameworkPackageId: input.typusFrameworkPackageId,
+                typusDovSinglePackageId: input.typusDovSinglePackageId,
+                typusDovSingleRegistry: input.typusDovSingleRegistry,
+                mfudPackageId: input.mfudPackageId,
+                mfudRegistry: input.mfudRegistry,
+                typeArguments: input.typeArguments,
+                index: input.index,
+                receipts: [input.tx.object(receipt)],
+                user: input.user,
+            });
+        }
+        else {
+            var receipt = input.tx.moveCall({
+                target: "0x1::option::destroy_some",
+                typeArguments: ["".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt")],
+                arguments: [input.tx.object(result[1])],
+            });
+            input.tx = (0, user_entry_1.getRedeemTx)({
+                tx: input.tx,
+                typusFrameworkOriginPackageId: input.typusFrameworkOriginPackageId,
+                typusFrameworkPackageId: input.typusFrameworkPackageId,
+                typusDovSinglePackageId: input.typusDovSinglePackageId,
+                typusDovSingleRegistry: input.typusDovSingleRegistry,
+                typeArguments: input.typeArguments,
+                index: input.index,
+                receipts: [input.tx.object(receipt)],
+                user: input.user,
+            });
+        }
+    }
+    else {
+        input.tx.moveCall({
+            target: "".concat(input.typusFrameworkPackageId, "::vault::transfer_deposit_receipt"),
+            arguments: [input.tx.object(result[1]), input.tx.pure(input.user)],
+        });
+    }
     return input.tx;
 }
 exports.getHarvestTx = getHarvestTx;

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

@@ -110,4 +110,13 @@ interface SettleEvent {
     timestampMs: string | null | undefined;
     txDigest: string;
 }
+export declare function parseBidEvents(datas: SuiEvent[], end_ts_ms: any): Promise<Map<string, NewBidEvent[]>>;
+interface NewBidEvent {
+    signer: string;
+    index: string;
+    size: string;
+    ts_ms: string;
+    timestampMs: string | null | undefined;
+    txDigest: string;
+}
 export {};

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

@@ -36,7 +36,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertGroupEventToVaultHistory = exports.parseVaultHistory = exports.parseGroupEvents = exports.getVaultHistoryEvents = void 0;
+exports.parseBidEvents = exports.convertGroupEventToVaultHistory = exports.parseVaultHistory = exports.parseGroupEvents = exports.getVaultHistoryEvents = void 0;
 var token_1 = require("../token");
 function getVaultHistoryEvents(provider, originPackage, startTimeMs) {
     return __awaiter(this, void 0, void 0, function () {
@@ -252,3 +252,55 @@ function convertGroupEventToVaultHistory(groupEvent) {
     });
 }
 exports.convertGroupEventToVaultHistory = convertGroupEventToVaultHistory;
+function parseBidEvents(datas, end_ts_ms) {
+    return __awaiter(this, void 0, void 0, function () {
+        var results;
+        var _this = this;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, datas.reduce(function (promise, event) { return __awaiter(_this, void 0, void 0, function () {
+                        var map, functionType, action, parsedJson, index, bid_event, o_token, size, bid_events;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, promise];
+                                case 1:
+                                    map = _a.sent();
+                                    functionType = new RegExp("^([^::]+)::([^::]+)::([^<]+)").exec(event.type);
+                                    action = functionType[3];
+                                    // console.log(action);
+                                    if (action != "NewBidEvent") {
+                                        return [2 /*return*/, map];
+                                    }
+                                    parsedJson = event.parsedJson;
+                                    // console.log(parsedJson);
+                                    parsedJson.timestampMs = event.timestampMs;
+                                    parsedJson.txDigest = event.id.txDigest;
+                                    index = parsedJson.index.toString();
+                                    bid_event = parsedJson;
+                                    o_token = (0, token_1.typeArgToAsset)("0x" + parsedJson.o_token.name);
+                                    size = Number(parsedJson.size) / Math.pow(10, (0, token_1.assetToDecimal)(o_token));
+                                    bid_event.size = size.toString();
+                                    if (Number(bid_event.ts_ms) > end_ts_ms) {
+                                        return [2 /*return*/, map];
+                                    }
+                                    if (map.has(index)) {
+                                        bid_events = map.get(index);
+                                        bid_events.push(bid_event);
+                                    }
+                                    else {
+                                        bid_events = [bid_event];
+                                    }
+                                    map.set(index, bid_events);
+                                    return [2 /*return*/, map];
+                            }
+                        });
+                    }); }, Promise.resolve(new Map()))];
+                case 1:
+                    results = _a.sent();
+                    // console.log(results);
+                    return [2 /*return*/, results];
+            }
+        });
+    });
+}
+exports.parseBidEvents = parseBidEvents;

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

@@ -7,6 +7,7 @@ export interface PoolData {
     start_ms: string;
     num: number;
     remaining: number;
+    table: string;
 }
 export declare const necklaces: string[];
 export declare function getPoolMap(provider: SuiClient, nftConfig: any): Promise<Map<string, PoolData>>;
@@ -35,4 +36,5 @@ export interface Tails {
 }
 export declare function getLevelExp(level: number): number | undefined;
 export declare const LevelExpVec: number[];
+export declare function getTableTails(provider: SuiClient, parentId: string): Promise<Tails[]>;
 export {};

package/lib/utils/typus-nft/fetch.js

@@ -47,7 +47,7 @@ var __values = (this && this.__values) || function(o) {
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LevelExpVec = exports.getLevelExp = exports.fieldsToTails = exports.getTails = exports.getTailsIds = exports.getWhitelistMap = exports.getPoolMap = exports.necklaces = exports.getPool = void 0;
+exports.getTableTails = exports.LevelExpVec = exports.getLevelExp = exports.fieldsToTails = exports.getTails = exports.getTailsIds = exports.getWhitelistMap = exports.getPoolMap = exports.necklaces = exports.getPool = void 0;
 function getPool(provider, pool) {
     var _a;
     return __awaiter(this, void 0, void 0, function () {
@@ -64,6 +64,7 @@ function getPool(provider, pool) {
                         start_ms: fields.start_ms,
                         num: Number(fields.num),
                         remaining: Number(fields.tails.fields.contents.fields.size),
+                        table: fields.tails.fields.contents.fields.id.id,
                     };
                     return [2 /*return*/, poolData];
             }
@@ -111,6 +112,7 @@ function getPoolMap(provider, nftConfig) {
                                 start_ms: fields.start_ms,
                                 num: Number(fields.num),
                                 remaining: Number(fields.tails.fields.contents.fields.size),
+                                table: fields.tails.fields.contents.fields.id.id,
                             };
                             poolMap.set(necklace, poolData);
                             return [2 /*return*/];
@@ -252,13 +254,17 @@ function getTails(provider, tailsIds) {
 }
 exports.getTails = getTails;
 function fieldsToTails(fields) {
+    var id = fields.id.id;
+    if (fields.value) {
+        fields = fields.value.fields;
+    }
     // console.log(fields.attributes.fields.contents);
     var attributes = new Map();
     fields.attributes.fields.contents.forEach(function (f) { return attributes.set(f.fields.key, f.fields.value); });
     var u64_padding = new Map();
     fields.u64_padding.fields.contents.forEach(function (f) { return u64_padding.set(f.fields.key, f.fields.value); });
     var tails = {
-        id: fields.id.id,
+        id: id,
         name: fields.name,
         number: fields.number,
         url: fields.url,
@@ -293,3 +299,37 @@ function getLevelExp(level) {
 }
 exports.getLevelExp = getLevelExp;
 exports.LevelExpVec = [0, 0, 1000, 50000, 250000, 1000000, 5000000, 20000000];
+function getTableTails(provider, parentId) {
+    return __awaiter(this, void 0, void 0, function () {
+        var result, datas, tails, levelUsers;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, provider.getDynamicFields({
+                        parentId: parentId,
+                    })];
+                case 1:
+                    result = _a.sent();
+                    datas = result.data;
+                    _a.label = 2;
+                case 2:
+                    if (!result.hasNextPage) return [3 /*break*/, 4];
+                    return [4 /*yield*/, provider.getDynamicFields({
+                            parentId: parentId,
+                            cursor: result.nextCursor,
+                        })];
+                case 3:
+                    result = _a.sent();
+                    datas = datas.concat(result.data);
+                    return [3 /*break*/, 2];
+                case 4: return [4 /*yield*/, getTails(provider, datas.map(function (data) { return data.objectId; }))];
+                case 5:
+                    tails = _a.sent();
+                    levelUsers = [0, 0, 0, 0, 0, 0, 0];
+                    tails.forEach(function (tail) { return (levelUsers[Number(tail.level) - 1] += 1); });
+                    console.log("Level Users: ", levelUsers);
+                    return [2 /*return*/, tails];
+            }
+        });
+    });
+}
+exports.getTableTails = getTableTails;

package/package.json

@@ -2,7 +2,7 @@
     "name": "@typus/typus-sdk",
     "author": "Typus",
     "description": "typus sdk",
-    "version": "1.2.15",
+    "version": "1.2.17",
     "dependencies": {
         "@mysten/bcs": "^0.7.3",
         "@mysten/kiosk": "0.7.12",