@typus/typus-sdk 1.4.5 → 1.4.7

package/dist/src/auto-bid/view-function.js

@@ -0,0 +1,347 @@
+"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 __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;
+};
+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.getUserStrategies = getUserStrategies;
+exports.getStrategyPool = getStrategyPool;
+exports.getStrategies = getStrategies;
+exports.getStrategyIds = getStrategyIds;
+var bcs_1 = require("@mysten/bcs");
+var transactions_1 = require("@mysten/sui.js/transactions");
+var tools_1 = require("../utils/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, registry, strategyPool, user
+// typeArguments: string[] // [D_TOKEN, B_TOKEN]
+) {
+    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::view_user_strategies");
+                    transactionBlockArguments = [transactionBlock.pure(registry), 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(),
+                        };
+                        var my_bids = Array.from(new Map()).reduce(function (map, _a) {
+                            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+                            map[key] = value;
+                            return map;
+                        }, {});
+                        reader.readVec(function (reader, i) {
+                            reader.read16();
+                            var bidVault = {
+                                id: (0, tools_1.AddressFromBytes)(reader.readBytes(32)),
+                                depositToken: String.fromCharCode.apply(null, Array.from(reader.readBytes(reader.read8()))),
+                                bidToken: String.fromCharCode.apply(null, Array.from(reader.readBytes(reader.read8()))),
+                                incentiveToken: reader
+                                    .readVec(function (reader) {
+                                    return String.fromCharCode.apply(null, Array.from(reader.readBytes(reader.read8())));
+                                })
+                                    .at(0),
+                                index: reader.read64(),
+                                shareSupply: reader.read64(),
+                                metadata: String.fromCharCode.apply(null, Array.from(reader.readBytes(reader.read8()))),
+                                u64Padding: reader.readVec(function (reader) {
+                                    return reader.read64();
+                                }),
+                                bcsPadding: reader.readVec(function (reader) {
+                                    return reader.read8();
+                                }),
+                            };
+                            my_bids[bidVault.index + "-" + bidVault.id] = {
+                                bidVault: bidVault,
+                                share: reader.read64(),
+                            };
+                        });
+                        // console.log(my_bids);
+                        strategy.my_bids = my_bids;
+                        strategy.remaining_balance = strategy.u64_padding.at(0);
+                        strategy.gain_to_harvest = strategy.u64_padding.at(1);
+                        strategy.accumulated_cost = strategy.u64_padding.at(2);
+                        if (Number(strategy.bid_times) >= Number(strategy.max_times)) {
+                            strategy.status = "finished";
+                        }
+                        else if (!strategy.active) {
+                            strategy.status = "insufficient balance";
+                        }
+                        else {
+                            strategy.status = "active";
+                        }
+                        // console.log(strategy);
+                        strategies.push(strategy);
+                    });
+                    return [2 /*return*/, strategies];
+            }
+        });
+    });
+}
+function getStrategyPool(provider, strategyPool) {
+    return __awaiter(this, void 0, void 0, function () {
+        var pool, vaults, strategies, vaults_1, vaults_1_1, vault, signals, _a, _b, signal, strategyTable, strategy_pool;
+        var e_1, _c, e_2, _d;
+        var _e;
+        return __generator(this, function (_f) {
+            switch (_f.label) {
+                case 0: return [4 /*yield*/, provider.getObject({ id: strategyPool, options: { showContent: true } })];
+                case 1:
+                    pool = (_e = (_f.sent()).data) === null || _e === void 0 ? void 0 : _e.content.fields;
+                    vaults = pool.strategies.fields.contents;
+                    strategies = new Map();
+                    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 = new Map();
+                            try {
+                                for (_a = (e_2 = void 0, __values(vault.fields.value.fields.contents)), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                    signal = _b.value;
+                                    strategyTable = signal.fields.value.fields.contents;
+                                    // console.log(strategyTable);
+                                    signals.set(signal.fields.key, strategyTable.fields.id.id);
+                                }
+                            }
+                            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                            finally {
+                                try {
+                                    if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
+                                }
+                                finally { if (e_2) throw e_2.error; }
+                            }
+                            strategies.set(vault.fields.key, signals);
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (vaults_1_1 && !vaults_1_1.done && (_c = vaults_1.return)) _c.call(vaults_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    strategy_pool = {
+                        id: pool.id.id,
+                        strategies: strategies,
+                        authority: pool.authority,
+                    };
+                    return [2 /*return*/, strategy_pool];
+            }
+        });
+    });
+}
+function getStrategies(provider, strategyIds) {
+    return __awaiter(this, void 0, void 0, function () {
+        var strategies, len, results, results_1, results_1_1, result, fields;
+        var e_3, _a;
+        var _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    strategies = new Map();
+                    _c.label = 1;
+                case 1:
+                    if (!(strategyIds.length > 0)) return [3 /*break*/, 3];
+                    len = strategyIds.length > 50 ? 50 : strategyIds.length;
+                    return [4 /*yield*/, provider.multiGetObjects({ ids: strategyIds.splice(0, len), options: { showContent: true } })];
+                case 2:
+                    results = _c.sent();
+                    try {
+                        for (results_1 = (e_3 = void 0, __values(results)), results_1_1 = results_1.next(); !results_1_1.done; results_1_1 = results_1.next()) {
+                            result = results_1_1.value;
+                            fields = (_b = result.data) === null || _b === void 0 ? void 0 : _b.content.fields;
+                            // console.log(fields);
+                            strategies.set(fields.name, fields.value.fields);
+                        }
+                    }
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    finally {
+                        try {
+                            if (results_1_1 && !results_1_1.done && (_a = results_1.return)) _a.call(results_1);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                    }
+                    return [3 /*break*/, 1];
+                case 3: return [2 /*return*/, strategies];
+            }
+        });
+    });
+}
+function getStrategyIds(provider, parentId) {
+    return __awaiter(this, void 0, void 0, function () {
+        var result, datas;
+        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 [2 /*return*/, datas.map(function (data) { return data.objectId; })];
+            }
+        });
+    });
+}

package/dist/src/constants/constant.d.ts

@@ -0,0 +1,22 @@
+import { SuiClient } from "@mysten/sui.js/client";
+export declare const CLOCK = "0x6";
+export declare const PRICE_DECIMAL = 8;
+export declare const TOKEN_DECIMAL = 9;
+export declare const DEFAULT_TYPE_ARGUMENT = "0x2::sui::SUI";
+export declare const FAKE_TOKEN_TYPE_ARGUMENT = "0x27b3674c685046f66cad1d5496d2967894fa5329::token::USDC";
+export declare const TOKEN_NAME: string[];
+export declare const TOKEN_NAME_TO_MODULE: {
+    BTC: string;
+    ETH: string;
+    SUI: string;
+    USDC: string;
+};
+export declare const mainnetConnection: SuiClient;
+export declare const testnetConnection: SuiClient;
+export declare const ACTIVE_SUB_VAULT_TAG: number;
+export declare const DEACTIVATING_SUB_VAULT_TAG: number;
+export declare const INACTIVE_SUB_VAULT_TAG: number;
+export declare const WARMUP_SUB_VAULT_TAG: number;
+export declare const BIDDER_SUB_VAULT_TAG: number;
+export declare const PREMIUM_SUB_VAULT_TAG: number;
+export declare const PERFORMANCE_FEE_SUB_VAULT_TAG: number;

package/dist/src/constants/constant.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PERFORMANCE_FEE_SUB_VAULT_TAG = exports.PREMIUM_SUB_VAULT_TAG = exports.BIDDER_SUB_VAULT_TAG = exports.WARMUP_SUB_VAULT_TAG = exports.INACTIVE_SUB_VAULT_TAG = exports.DEACTIVATING_SUB_VAULT_TAG = exports.ACTIVE_SUB_VAULT_TAG = exports.testnetConnection = exports.mainnetConnection = exports.TOKEN_NAME_TO_MODULE = exports.TOKEN_NAME = exports.FAKE_TOKEN_TYPE_ARGUMENT = exports.DEFAULT_TYPE_ARGUMENT = exports.TOKEN_DECIMAL = exports.PRICE_DECIMAL = exports.CLOCK = void 0;
+var client_1 = require("@mysten/sui.js/client");
+exports.CLOCK = "0x6";
+exports.PRICE_DECIMAL = 8;
+exports.TOKEN_DECIMAL = 9;
+exports.DEFAULT_TYPE_ARGUMENT = "0x2::sui::SUI";
+exports.FAKE_TOKEN_TYPE_ARGUMENT = "0x27b3674c685046f66cad1d5496d2967894fa5329::token::USDC";
+exports.TOKEN_NAME = ["BTC", "ETH", "SUI", "USDC", "USDT", "APT", "DOGE"];
+exports.TOKEN_NAME_TO_MODULE = {
+    BTC: "btc",
+    ETH: "eth",
+    SUI: "sui",
+    USDC: "usdc",
+};
+exports.mainnetConnection = new client_1.SuiClient({
+    url: "https://fullnode.mainnet.sui.io:443/",
+});
+exports.testnetConnection = new client_1.SuiClient({
+    url: "https://fullnode.testnet.sui.io:443/",
+});
+exports.ACTIVE_SUB_VAULT_TAG = 0;
+exports.DEACTIVATING_SUB_VAULT_TAG = 1;
+exports.INACTIVE_SUB_VAULT_TAG = 2;
+exports.WARMUP_SUB_VAULT_TAG = 3;
+exports.BIDDER_SUB_VAULT_TAG = 4;
+exports.PREMIUM_SUB_VAULT_TAG = 5;
+exports.PERFORMANCE_FEE_SUB_VAULT_TAG = 6;

package/dist/src/constants/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./token";
+export * from "./constant";

package/dist/src/constants/index.js

@@ -0,0 +1,18 @@
+"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("./token"), exports);
+__exportStar(require("./constant"), exports);

package/dist/src/constants/token.d.ts

@@ -0,0 +1,51 @@
+export declare function typeArgsToAssets(typeArgs: string[]): string[];
+export declare function typeArgToAsset(typeArg: string): string;
+export declare function assetToDecimal(asset: string): number | undefined;
+export declare const tokenType: {
+    MAINNET: {
+        SUI: string;
+        BTC: string;
+        ETH: string;
+        USDC: string;
+        USDT: string;
+        CETUS: string;
+        BUCK: string;
+        SOL: string;
+        TURBOS: string;
+        APT: string;
+        FUD: string;
+        MFUD: string;
+        INJ: string;
+        SEI: string;
+        AFSUI: string;
+        JUP: string;
+        NAVX: string;
+        USDY: string;
+        TEXP: string;
+        SCA: string;
+        VSUI: string;
+        HASUI: string;
+    };
+    TESTNET: {
+        SUI: string;
+        CETUS: string;
+        BUCK: string;
+        SOL: string;
+        TURBOS: string;
+        APT: string;
+        FUD: string;
+        MFUD: string;
+        USDT: string;
+        AFSUI: string;
+        INJ: string;
+        SEI: string;
+        USDY: string;
+        TEXP: string;
+        SCA: string;
+        BTC: string;
+        ETH: string;
+        USDC: string;
+    };
+};
+export type TOKEN = "SUI" | "CETUS" | "BUCK" | "SOL" | "TURBOS" | "APT" | "FUD" | "MFUD" | "USDT" | "AFSUI" | "INJ" | "SEI" | "USDY" | "TEXP" | "SCA" | "BTC" | "ETH" | "USDC";
+export declare function typeArgToToken(typeArg: string): string;

package/dist/src/constants/token.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenType = void 0;
+exports.typeArgsToAssets = typeArgsToAssets;
+exports.typeArgToAsset = typeArgToAsset;
+exports.assetToDecimal = assetToDecimal;
+exports.typeArgToToken = typeArgToToken;
+var utils_1 = require("@mysten/sui.js/utils");
+function typeArgsToAssets(typeArgs) {
+    var assets = typeArgs.map(function (x) { return typeArgToAsset(x); });
+    return assets;
+}
+function typeArgToAsset(typeArg) {
+    var typeArgs = typeArg.split("::");
+    switch ((0, utils_1.normalizeSuiAddress)(typeArgs[0])) {
+        case "0x549e8b69270defbfafd4f94e17ec44cdbdd99820b33bda2278dea3b9a32d3f55":
+            return "VSUI";
+        case "0x027792d9fed7f9844eb4839566001bb6f6cb4804f66aa2da6fe1ee242d896881":
+            return "WBTC";
+        case "0xaf8cd5edc19c4512f4259f0bee101a40d41ebed738ade5874359610ef8eeced5":
+            return "WETH";
+        case "0xb7844e289a8410e50fb3ca48d69eb9cf29e27d223ef90353fe1bd8e27ff8f3f8":
+            return "WSOL";
+        case "0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf":
+            return "USDC";
+        case "0xc060006111016b8a020ad5b33834984a437aaa7d3c74c18e09a95d48aceab08c":
+            return "USDT";
+        case "0x5d1f47ea69bb0de31c313d7acf89b890dbb8991ea8e03c6c355171f84bb1ba4a":
+            return "TURBOS";
+        case "0x3a5143bb1196e3bcdfab6203d1683ae29edd26294fc8bfeafe4aaa9d2704df37":
+            return "APT";
+        case "0x76cb819b01abed502bee8a702b4c2d547532c12f25001c9dea795a5e631c26f1":
+            return "FUD";
+        case "0xf325ce1300e8dac124071d3152c5c5ee6174914f8bc2161e88329cf579246efc":
+            return "AFSUI";
+        case "0x7016aae72cfc67f2fadf55769c0a7dd54291a583b63051a5ed71081cce836ac6":
+            return "SCA";
+        case "0x960b531667636f39e85867775f52f6b1f220a058c4de786905bdf761e06a56bb":
+            return "USDY";
+        default:
+            if (typeArgs[2] == "BTC") {
+                return "WBTC";
+            }
+            else if (typeArgs[2] == "ETH") {
+                return "WETH";
+            }
+            else if (typeArgs[2] == "SOL") {
+                return "WSOL";
+            }
+            return typeArgs[2];
+    }
+}
+function assetToDecimal(asset) {
+    switch (asset) {
+        case "SUI":
+            return 9;
+        case "BTC":
+            return 8;
+        case "ETH":
+            return 8;
+        case "WBTC":
+            return 8;
+        case "WETH":
+            return 8;
+        case "SOL":
+            return 8;
+        case "WSOL":
+            return 8;
+        case "USDC":
+            return 6;
+        case "USDT":
+            return 6;
+        case "USDY":
+            return 6;
+        case "CETUS":
+            return 9;
+        case "TURBOS":
+            return 9;
+        case "APT":
+            return 8;
+        case "FUD":
+            return 5;
+        case "MFUD":
+            return 6;
+        case "INJ":
+        case "SEI":
+        case "JUP":
+            return 8;
+        case "BUCK":
+            return 9;
+        case "AFSUI":
+            return 9;
+        case "NAVX":
+            return 9;
+        case "SCA":
+            return 9;
+        case "HASUI":
+            return 9;
+        case "VSUI":
+            return 9;
+    }
+}
+exports.tokenType = {
+    MAINNET: {
+        SUI: "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI",
+        BTC: "0x027792d9fed7f9844eb4839566001bb6f6cb4804f66aa2da6fe1ee242d896881::coin::COIN",
+        ETH: "0xaf8cd5edc19c4512f4259f0bee101a40d41ebed738ade5874359610ef8eeced5::coin::COIN",
+        USDC: "0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf::coin::COIN",
+        USDT: "0xc060006111016b8a020ad5b33834984a437aaa7d3c74c18e09a95d48aceab08c::coin::COIN",
+        CETUS: "0x06864a6f921804860930db6ddbe2e16acdf8504495ea7481637a1c8b9a8fe54b::cetus::CETUS",
+        BUCK: "0xce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2::buck::BUCK",
+        SOL: "0xb7844e289a8410e50fb3ca48d69eb9cf29e27d223ef90353fe1bd8e27ff8f3f8::coin::COIN",
+        TURBOS: "0x5d1f47ea69bb0de31c313d7acf89b890dbb8991ea8e03c6c355171f84bb1ba4a::turbos::TURBOS",
+        APT: "0x3a5143bb1196e3bcdfab6203d1683ae29edd26294fc8bfeafe4aaa9d2704df37::coin::COIN",
+        FUD: "0x76cb819b01abed502bee8a702b4c2d547532c12f25001c9dea795a5e631c26f1::fud::FUD",
+        MFUD: "0xd8f04cd2a16c19c17428c3b4c22b01dd06740423b93fb7ee88fbe2676a82849d::mfud::MFUD",
+        INJ: "0xcac46c81bbe1e516c65f4c3e5da81e7092cc2e70218deafb31f1c8d5fcc9dae3::inj::INJ",
+        SEI: "0xcac46c81bbe1e516c65f4c3e5da81e7092cc2e70218deafb31f1c8d5fcc9dae3::sei::SEI",
+        AFSUI: "0xf325ce1300e8dac124071d3152c5c5ee6174914f8bc2161e88329cf579246efc::afsui::AFSUI",
+        JUP: "0x3dc8710253682b53706bd110d51fd9b298d5bb923b535fb7bca88e049208c508::jup::JUP",
+        NAVX: "0xa99b8952d4f7d947ea77fe0ecdcc9e5fc0bcab2841d6e2a5aa00c3044e5544b5::navx::NAVX",
+        USDY: "0x960b531667636f39e85867775f52f6b1f220a058c4de786905bdf761e06a56bb::usdy::USDY",
+        TEXP: "0x37816d28c34cc0df82655ca97b3f066112a5f3c202cbb4aaa76c8af54e779750::tails_exp::TAILS_EXP",
+        SCA: "0x7016aae72cfc67f2fadf55769c0a7dd54291a583b63051a5ed71081cce836ac6::sca::SCA",
+        VSUI: "0x549e8b69270defbfafd4f94e17ec44cdbdd99820b33bda2278dea3b9a32d3f55::cert::CERT",
+        HASUI: "0xbde4ba4c2e274a60ce15c1cfff9e5c42e41654ac8b6d906a57efa4bd3c29f47d::hasui::HASUI",
+    },
+    TESTNET: {
+        SUI: "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI",
+        CETUS: "0xb69a412ba4b22137088183da5e5042d37ba17580897884f00f959d4135d3e1a7::cetus::CETUS",
+        BUCK: "0x879cd4804fe865897090e26eceb9f7a7cfda7dda1b2529a81631fa567e67375c::buck::BUCK",
+        SOL: "0x879cd4804fe865897090e26eceb9f7a7cfda7dda1b2529a81631fa567e67375c::sol::SOL",
+        TURBOS: "0xebc68999f399a5ba121f8e59c0940eaa0e074e30454403357b93b25af9f30117::turbos::TURBOS",
+        APT: "0xdede697a5748d20ebff2aabf3f2fd5bd9e41afb1a624b636cddc6df69078bd22::apt::APT",
+        FUD: "0x461efa7ee5aa1b27e44450d79e2104e7fc0991461e9eb1c2a3fc1f44cd554856::fud::FUD",
+        MFUD: "0x7755ff79f0f27256c73e6c197e25b407ef6d4b9bd6e1af8cdd50fef28f84712c::mfud::MFUD",
+        USDT: "0xa38dad920880f81ea514de6db007d3a84e9116a29c60b3e69bbe418c2d9f553c::usdt::USDT",
+        AFSUI: "0xd31923b6821fb7ba32d23e514b43d307da6ef991f9ef1af2cc4e26a0992ac87a::afsui::AFSUI",
+        INJ: "0xfd3d56e007e3ae44d74b6a6840de0bd04a3724360abd89ae683ca7d592bbb49e::inj::INJ",
+        SEI: "0xfd3d56e007e3ae44d74b6a6840de0bd04a3724360abd89ae683ca7d592bbb49e::sei::SEI",
+        USDY: "0x579809c614d4388ed821c9f304bb741715cdf4a718707eb7c6fcf7b7189870ef::usdy::USDY",
+        TEXP: "0x9b43ee208a3b235810c145bca1161d1a71d08bfe76b1e55bb3db319ea95d0149::tails_exp::TAILS_EXP",
+        SCA: "0xd33ea459d9e667c112f5168464a885a654d7bc3fd6903720aaa8cf495a32a77e::sca::SCA",
+        BTC: "0x949572061c09bbedef3ac4ffc42e58632291616f0605117cec86d840e09bf519::btc::BTC",
+        ETH: "0x949572061c09bbedef3ac4ffc42e58632291616f0605117cec86d840e09bf519::eth::ETH",
+        USDC: "0x949572061c09bbedef3ac4ffc42e58632291616f0605117cec86d840e09bf519::usdc::USDC",
+    },
+};
+function typeArgToToken(typeArg) {
+    // console.log(typeArg);
+    var typeArgs = typeArg.split("::");
+    switch ((0, utils_1.normalizeSuiAddress)(typeArgs[0])) {
+        case "0x027792d9fed7f9844eb4839566001bb6f6cb4804f66aa2da6fe1ee242d896881":
+            return "BTC";
+        case "0xaf8cd5edc19c4512f4259f0bee101a40d41ebed738ade5874359610ef8eeced5":
+            return "ETH";
+        case "0xb7844e289a8410e50fb3ca48d69eb9cf29e27d223ef90353fe1bd8e27ff8f3f8":
+            return "SOL";
+        case "0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf":
+            return "USDC";
+        case "0xc060006111016b8a020ad5b33834984a437aaa7d3c74c18e09a95d48aceab08c":
+            return "USDT";
+        case "0x5d1f47ea69bb0de31c313d7acf89b890dbb8991ea8e03c6c355171f84bb1ba4a":
+            return "TURBOS";
+        case "0x3a5143bb1196e3bcdfab6203d1683ae29edd26294fc8bfeafe4aaa9d2704df37":
+            return "APT";
+        case "0x76cb819b01abed502bee8a702b4c2d547532c12f25001c9dea795a5e631c26f1":
+            return "FUD";
+        case "0xf325ce1300e8dac124071d3152c5c5ee6174914f8bc2161e88329cf579246efc":
+            return "AFSUI";
+        case "0x7016aae72cfc67f2fadf55769c0a7dd54291a583b63051a5ed71081cce836ac6":
+            return "SCA";
+        case "0x960b531667636f39e85867775f52f6b1f220a058c4de786905bdf761e06a56bb":
+            return "USDY";
+        default:
+            return typeArgs[2];
+    }
+}

package/dist/src/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./airdrop";
+export * from "./auto-bid";
+export * from "./constants";
+export * from "./leaderboard";
+export * from "./tails-exp-dice";
+export * from "./tails-staking";
+export * from "./typus-dov-single-v2";
+export * from "./typus-nft";
+export * from "./typus-perp";
+export * from "./user";
+export * from "./utils";