@typus/typus-sdk 1.4.3-d → 1.4.3-f

package/{dist/auto-bid/user-entry.js → src/auto-bid/user-entry.ts}

@@ -1,26 +1,5 @@
-"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.getNewStrategyTx = getNewStrategyTx;
-exports.getCloseStrategyTx = getCloseStrategyTx;
-exports.getWithdrawProfitStrategyTx = getWithdrawProfitStrategyTx;
-exports.getUpdateStrategyTx = getUpdateStrategyTx;
-var transactions_1 = require("@mysten/sui.js/transactions");
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+
 /**
     entry fun new_strategy<B_TOKEN>(
         strategy_pool: &mut StrategyPool,
@@ -34,17 +13,33 @@ var transactions_1 = require("@mysten/sui.js/transactions");
         ctx: &mut TxContext
     )
 */
-function getNewStrategyTx(gasBudget, packageId, typeArguments, // D_TOKEN, B_TOKEN
-registry, strategy_pool, vault_index, signal_index, coins, amount, size, price_percentage, max_times, target_rounds) {
-    var tx = new transactions_1.TransactionBlock();
+
+export function getNewStrategyTx(
+    gasBudget: number,
+    packageId: string,
+    typeArguments: string[], // D_TOKEN, B_TOKEN
+    registry: string,
+    strategy_pool: string,
+    vault_index: string,
+    signal_index: string,
+    coins: string[],
+    amount: string,
+    size: string,
+    price_percentage: string,
+    max_times: string,
+    target_rounds: string[]
+) {
+    let tx = new 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];
+        // B_TOKEN
+        typeArguments[1] == "0x2::sui::SUI" ||
+        typeArguments[1] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI"
+    ) {
+        let [input_coin] = tx.splitCoins(tx.gas, [tx.pure(amount)]);
         tx.moveCall({
-            target: "".concat(packageId, "::auto_bid::new_strategy"),
-            typeArguments: typeArguments,
+            target: `${packageId}::auto_bid::new_strategy`,
+            typeArguments,
             arguments: [
                 tx.object(registry),
                 tx.object(strategy_pool),
@@ -57,16 +52,21 @@ registry, strategy_pool, vault_index, signal_index, coins, amount, size, price_p
                 input_coin,
             ],
         });
-    }
-    else {
-        var coin = coins.pop();
+    } else {
+        const coin = coins.pop()!;
+
         if (coins.length > 0) {
-            tx.mergeCoins(tx.object(coin), coins.map(function (coin) { return tx.object(coin); }));
+            tx.mergeCoins(
+                tx.object(coin),
+                coins.map((coin) => tx.object(coin))
+            );
         }
-        var _b = __read(tx.splitCoins(tx.object(coin), [tx.pure(amount)]), 1), input_coin = _b[0];
+
+        let [input_coin] = tx.splitCoins(tx.object(coin), [tx.pure(amount)]);
+
         tx.moveCall({
-            target: "".concat(packageId, "::auto_bid::new_strategy"),
-            typeArguments: typeArguments,
+            target: `${packageId}::auto_bid::new_strategy`,
+            typeArguments,
             arguments: [
                 tx.object(registry),
                 tx.object(strategy_pool),
@@ -81,8 +81,10 @@ registry, strategy_pool, vault_index, signal_index, coins, amount, size, price_p
         });
     }
     tx.setGasBudget(gasBudget);
+
     return tx;
 }
+
 /**
     entry fun close_strategy<D_TOKEN, B_TOKEN>(
         strategy_pool: &mut StrategyPoolV2,
@@ -92,30 +94,58 @@ registry, strategy_pool, vault_index, signal_index, coins, amount, size, price_p
         ctx: &mut TxContext
     )
 */
-function getCloseStrategyTx(gasBudget, packageId, typeArguments, // D_TOKEN, B_TOKEN
-registry, strategy_pool, vault_index, signal_index, strategy_index, sender, txBlock) {
-    var tx = txBlock ? txBlock : new transactions_1.TransactionBlock();
-    var _a = __read(tx.moveCall({
-        target: "".concat(packageId, "::auto_bid::close_strategy"),
-        typeArguments: typeArguments,
+
+export function getCloseStrategyTx(
+    gasBudget: number,
+    packageId: string,
+    typeArguments: string[], // D_TOKEN, B_TOKEN
+    registry: string,
+    strategy_pool: string,
+    vault_index: string,
+    signal_index: string,
+    strategy_index: string,
+    sender: string,
+    txBlock?: TransactionBlock
+) {
+    let tx = txBlock ? txBlock : new TransactionBlock();
+
+    let [d_token, b_token] = tx.moveCall({
+        target: `${packageId}::auto_bid::close_strategy`,
+        typeArguments,
         arguments: [tx.object(registry), tx.object(strategy_pool), tx.pure(vault_index), tx.pure(signal_index), tx.pure(strategy_index)],
-    }), 2), d_token = _a[0], b_token = _a[1];
+    });
+
     tx.transferObjects([d_token, b_token], sender);
     tx.setGasBudget(gasBudget);
+
     return tx;
 }
-function getWithdrawProfitStrategyTx(gasBudget, packageId, typeArguments, // D_TOKEN, B_TOKEN
-registry, strategy_pool, vault_index, signal_index, strategy_index, sender, txBlock) {
-    var tx = txBlock ? txBlock : new transactions_1.TransactionBlock();
-    var d_token = tx.moveCall({
-        target: "".concat(packageId, "::auto_bid::withdraw_profit"),
-        typeArguments: typeArguments,
+
+export function getWithdrawProfitStrategyTx(
+    gasBudget: number,
+    packageId: string,
+    typeArguments: string[], // D_TOKEN, B_TOKEN
+    registry: string,
+    strategy_pool: string,
+    vault_index: string,
+    signal_index: string,
+    strategy_index: string,
+    sender: string,
+    txBlock?: TransactionBlock
+) {
+    let tx = txBlock ? txBlock : new TransactionBlock();
+    let d_token = tx.moveCall({
+        target: `${packageId}::auto_bid::withdraw_profit`,
+        typeArguments,
         arguments: [tx.object(registry), tx.object(strategy_pool), tx.pure(vault_index), tx.pure(signal_index), tx.pure(strategy_index)],
     });
+
     tx.transferObjects([d_token], sender);
     tx.setGasBudget(gasBudget);
+
     return tx;
 }
+
 /**
     entry fun update_strategy<D_TOKEN, B_TOKEN>(
         strategy_pool: &mut StrategyPoolV2,
@@ -130,18 +160,36 @@ registry, strategy_pool, vault_index, signal_index, strategy_index, sender, txBl
         ctx: & TxContext
     )
 */
-function getUpdateStrategyTx(gasBudget, packageId, typeArguments, // D_TOKEN, B_TOKEN
-registry, strategy_pool, vault_index, signal_index, strategy_index, coins, amount, size, price_percentage, max_times, target_rounds) {
-    var tx = new transactions_1.TransactionBlock();
+
+export function getUpdateStrategyTx(
+    gasBudget: number,
+    packageId: string,
+    typeArguments: string[], // D_TOKEN, B_TOKEN
+    registry: string,
+    strategy_pool: string,
+    vault_index: string,
+    signal_index: string,
+    strategy_index: string,
+    coins: string[],
+    amount: string,
+    size: string | null,
+    price_percentage: string | null,
+    max_times: string | null,
+    target_rounds: string[]
+) {
+    let tx = new TransactionBlock();
+
     if (
-    // B_TOKEN
-    typeArguments[1] == "0x2::sui::SUI" ||
-        typeArguments[1] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI") {
+        // B_TOKEN
+        typeArguments[1] == "0x2::sui::SUI" ||
+        typeArguments[1] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI"
+    ) {
         if (amount) {
-            var _a = __read(tx.splitCoins(tx.gas, [tx.pure(amount)]), 1), input_coin = _a[0];
+            const [input_coin] = tx.splitCoins(tx.gas, [tx.pure(amount)]);
+
             tx.moveCall({
-                target: "".concat(packageId, "::auto_bid::update_strategy"),
-                typeArguments: typeArguments,
+                target: `${packageId}::auto_bid::update_strategy`,
+                typeArguments,
                 arguments: [
                     tx.object(registry),
                     tx.object(strategy_pool),
@@ -155,11 +203,10 @@ registry, strategy_pool, vault_index, signal_index, strategy_index, coins, amoun
                     tx.makeMoveVec({ objects: [input_coin] }),
                 ],
             });
-        }
-        else {
+        } else {
             tx.moveCall({
-                target: "".concat(packageId, "::auto_bid::update_strategy"),
-                typeArguments: typeArguments,
+                target: `${packageId}::auto_bid::update_strategy`,
+                typeArguments,
                 arguments: [
                     tx.object(registry),
                     tx.object(strategy_pool),
@@ -174,16 +221,21 @@ registry, strategy_pool, vault_index, signal_index, strategy_index, coins, amoun
                 ],
             });
         }
-    }
-    else {
-        var coin = coins.pop();
+    } else {
+        const coin = coins.pop()!;
+
         if (coins.length > 0) {
-            tx.mergeCoins(tx.object(coin), coins.map(function (coin) { return tx.object(coin); }));
+            tx.mergeCoins(
+                tx.object(coin),
+                coins.map((coin) => tx.object(coin))
+            );
         }
-        var _b = __read(tx.splitCoins(tx.object(coin), [tx.pure(amount)]), 1), input_coin = _b[0];
+
+        const [input_coin] = tx.splitCoins(tx.object(coin), [tx.pure(amount)]);
+
         tx.moveCall({
-            target: "".concat(packageId, "::auto_bid::update_strategy"),
-            typeArguments: typeArguments,
+            target: `${packageId}::auto_bid::update_strategy`,
+            typeArguments,
             arguments: [
                 tx.object(registry),
                 tx.object(strategy_pool),
@@ -199,5 +251,6 @@ registry, strategy_pool, vault_index, signal_index, strategy_index, coins, amoun
         });
     }
     tx.setGasBudget(gasBudget);
+
     return tx;
 }

package/src/auto-bid/view-function.ts

@@ -0,0 +1,285 @@
+import { SuiClient, SuiEventFilter } from "@mysten/sui.js/client";
+import { assetToDecimal, typeArgToAsset } from "src/constants/token";
+import { BCS, BcsReader, fromB58, fromB64, getSuiMoveConfig } from "@mysten/bcs";
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+import { AddressFromBytes } from "src/utils/tools";
+import { BidShare, BidVault } from "src/typus-dov-single-v2/view-function";
+
+let bcs = new BCS(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>",
+});
+
+export async function getUserStrategies(
+    provider: SuiClient,
+    packageId: string,
+    registry: string,
+    strategyPool: string,
+    user: string
+    // typeArguments: string[] // [D_TOKEN, B_TOKEN]
+) {
+    let transactionBlock = new TransactionBlock();
+    let target = `${packageId}::auto_bid::view_user_strategies` as any;
+    let transactionBlockArguments = [transactionBlock.pure(registry), transactionBlock.pure(strategyPool), transactionBlock.pure(user)];
+    transactionBlock.moveCall({
+        target,
+        typeArguments: [],
+        arguments: transactionBlockArguments,
+    });
+    let results = (await provider.devInspectTransactionBlock({ transactionBlock, sender: user })).results;
+
+    // @ts-ignore
+    let objBCS = results[0].returnValues[0][0];
+    // console.log(objBCS.length);
+    // console.log(objBCS.toString());
+
+    // let strategies = bcs.de("vector<StrategyV2>", objBCS.toString(), "base64");
+    // console.log(strategies);
+
+    let reader = new BcsReader(new Uint8Array(objBCS));
+
+    var strategies: StrategyV2[] = [];
+
+    reader.readVec((reader, i) => {
+        reader.read16();
+        let strategy = {
+            id: AddressFromBytes(reader.readBytes(32)),
+            vault_index: reader.read64(),
+            signal_index: reader.read64(),
+            user: AddressFromBytes(reader.readBytes(32)),
+            price_percentage: reader.read64(),
+            size: reader.read64(),
+            max_times: reader.read64(),
+            target_rounds: reader.readVec((reader) => {
+                return reader.read64();
+            }),
+            receipts: reader.readVec((reader) => {
+                return {
+                    id: AddressFromBytes(reader.readBytes(32)),
+                    vid: AddressFromBytes(reader.readBytes(32)),
+                    index: reader.read64(),
+                    metadata: String.fromCharCode.apply(null, Array.from(reader.readBytes(reader.read8()))),
+                    u64_padding: reader.readVec((reader) => {
+                        return reader.read64();
+                    }),
+                };
+            }),
+            active: reader.read8(),
+            u64_padding: reader.readVec((reader) => {
+                return reader.read64();
+            }),
+            bid_times: reader.read64(),
+            bid_round: reader.read64(),
+            bid_ts_ms: reader.read64(),
+            bid_rounds: reader.readVec((reader) => {
+                return reader.read64();
+            }),
+            accumulated_profit: reader.read64(),
+            strategy_index: reader.read64(),
+        } as unknown as StrategyV2;
+
+        let my_bids = Array.from(new Map()).reduce((map, [key, value]) => {
+            map[key] = value;
+            return map;
+        }, {});
+        reader.readVec((reader, i) => {
+            reader.read16();
+            let bidVault = {
+                id: 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((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((reader) => {
+                    return reader.read64();
+                }),
+                bcsPadding: reader.readVec((reader) => {
+                    return reader.read8();
+                }),
+            } as BidVault;
+            my_bids[bidVault.index + "-" + bidVault.id] = {
+                bidVault,
+                share: reader.read64(),
+            } as BidShare;
+        });
+        // 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 strategies;
+}
+
+export async function getStrategyPool(provider: SuiClient, strategyPool: string) {
+    // @ts-ignore
+    const pool = (await provider.getObject({ id: strategyPool, options: { showContent: true } })).data?.content.fields;
+    // console.log(pool);
+
+    // console.log(pool.strategies.fields.contents.fields);
+
+    let vaults = pool.strategies.fields.contents;
+    // console.log("vaults: ", vaults);
+
+    let strategies = new Map<string, Map<string, string>>();
+
+    for (let vault of vaults) {
+        let signals = new Map<string, string>();
+
+        for (let signal of vault.fields.value.fields.contents) {
+            let strategyTable = signal.fields.value.fields.contents;
+            // console.log(strategyTable);
+            signals.set(signal.fields.key, strategyTable.fields.id.id);
+        }
+        strategies.set(vault.fields.key, signals);
+    }
+
+    let strategy_pool: StrategyPoolV2 = {
+        id: pool.id.id,
+        strategies,
+        authority: pool.authority,
+    };
+
+    return strategy_pool;
+}
+
+export interface StrategyPoolV2 {
+    id: string;
+    strategies: Map<string, Map<string, string>>;
+    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;
+    u64_padding: string[];
+    // log
+    bid_times: string;
+    bid_round: string;
+    bid_ts_ms: string;
+    bid_rounds: string[];
+    accumulated_profit: string;
+    remaining_balance: string | undefined;
+    gain_to_harvest: string | undefined;
+    accumulated_cost: string | undefined;
+    my_bids: { [key: string]: BidShare };
+    status: "active" | "insufficient balance" | "finished";
+}
+
+export interface TypusBidReceipt {
+    id: string;
+    vid: string;
+    index: string;
+    metadata: string;
+    u64_padding: string[];
+}
+
+export async function getStrategies(provider: SuiClient, strategyIds: string[]) {
+    let strategies = new Map<string, StrategyV2>();
+
+    while (strategyIds.length > 0) {
+        let len = strategyIds.length > 50 ? 50 : strategyIds.length;
+
+        const results = await provider.multiGetObjects({ ids: strategyIds.splice(0, len), options: { showContent: true } });
+
+        for (let result of results) {
+            // @ts-ignore
+            const fields = result.data?.content.fields;
+            // console.log(fields);
+            strategies.set(fields.name, fields.value.fields as StrategyV2);
+        }
+    }
+    return strategies;
+}
+
+export async function getStrategyIds(provider: SuiClient, parentId: string) {
+    var result = await provider.getDynamicFields({
+        parentId,
+    });
+
+    var datas = result.data;
+
+    while (result.hasNextPage) {
+        result = await provider.getDynamicFields({
+            parentId,
+            cursor: result.nextCursor,
+        });
+        datas = datas.concat(result.data);
+    }
+
+    return datas.map((data) => data.objectId);
+}

package/src/constants/constant.ts

@@ -0,0 +1,32 @@
+import { SuiClient } from "@mysten/sui.js/client";
+
+export const CLOCK = "0x6";
+
+export const PRICE_DECIMAL = 8;
+export const TOKEN_DECIMAL = 9;
+
+export const DEFAULT_TYPE_ARGUMENT = "0x2::sui::SUI";
+export const FAKE_TOKEN_TYPE_ARGUMENT = "0x27b3674c685046f66cad1d5496d2967894fa5329::token::USDC";
+export const TOKEN_NAME = ["BTC", "ETH", "SUI", "USDC", "USDT", "APT", "DOGE"];
+export const TOKEN_NAME_TO_MODULE = {
+    BTC: "btc",
+    ETH: "eth",
+    SUI: "sui",
+    USDC: "usdc",
+};
+
+export const mainnetConnection = new SuiClient({
+    url: "https://fullnode.mainnet.sui.io:443/",
+});
+
+export const testnetConnection = new SuiClient({
+    url: "https://fullnode.testnet.sui.io:443/",
+});
+
+export const ACTIVE_SUB_VAULT_TAG: number = 0;
+export const DEACTIVATING_SUB_VAULT_TAG: number = 1;
+export const INACTIVE_SUB_VAULT_TAG: number = 2;
+export const WARMUP_SUB_VAULT_TAG: number = 3;
+export const BIDDER_SUB_VAULT_TAG: number = 4;
+export const PREMIUM_SUB_VAULT_TAG: number = 5;
+export const PERFORMANCE_FEE_SUB_VAULT_TAG: number = 6;

package/{dist/constants/token.js → src/constants/token.ts}

@@ -1,18 +1,13 @@
-"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); });
+import { normalizeSuiAddress } from "@mysten/sui.js/utils";
+
+export function typeArgsToAssets(typeArgs: string[]): string[] {
+    let assets = typeArgs.map((x) => typeArgToAsset(x));
     return assets;
 }
-function typeArgToAsset(typeArg) {
-    var typeArgs = typeArg.split("::");
-    switch ((0, utils_1.normalizeSuiAddress)(typeArgs[0])) {
+
+export function typeArgToAsset(typeArg: string): string {
+    let typeArgs = typeArg.split("::");
+    switch (normalizeSuiAddress(typeArgs[0])) {
         case "0x549e8b69270defbfafd4f94e17ec44cdbdd99820b33bda2278dea3b9a32d3f55":
             return "VSUI";
         case "0x027792d9fed7f9844eb4839566001bb6f6cb4804f66aa2da6fe1ee242d896881":
@@ -40,17 +35,16 @@ function typeArgToAsset(typeArg) {
         default:
             if (typeArgs[2] == "BTC") {
                 return "WBTC";
-            }
-            else if (typeArgs[2] == "ETH") {
+            } else if (typeArgs[2] == "ETH") {
                 return "WETH";
-            }
-            else if (typeArgs[2] == "SOL") {
+            } else if (typeArgs[2] == "SOL") {
                 return "WSOL";
             }
             return typeArgs[2];
     }
 }
-function assetToDecimal(asset) {
+
+export function assetToDecimal(asset: string): number | undefined {
     switch (asset) {
         case "SUI":
             return 9;
@@ -100,7 +94,8 @@ function assetToDecimal(asset) {
             return 9;
     }
 }
-exports.tokenType = {
+
+export const tokenType = {
     MAINNET: {
         SUI: "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI",
         BTC: "0x027792d9fed7f9844eb4839566001bb6f6cb4804f66aa2da6fe1ee242d896881::coin::COIN",
@@ -146,10 +141,31 @@ exports.tokenType = {
         USDC: "0x949572061c09bbedef3ac4ffc42e58632291616f0605117cec86d840e09bf519::usdc::USDC",
     },
 };
-function typeArgToToken(typeArg) {
+
+export type TOKEN =
+    | "SUI"
+    | "CETUS"
+    | "BUCK"
+    | "SOL"
+    | "TURBOS"
+    | "APT"
+    | "FUD"
+    | "MFUD"
+    | "USDT"
+    | "AFSUI"
+    | "INJ"
+    | "SEI"
+    | "USDY"
+    | "TEXP"
+    | "SCA"
+    | "BTC"
+    | "ETH"
+    | "USDC";
+
+export function typeArgToToken(typeArg: string): string {
     // console.log(typeArg);
-    var typeArgs = typeArg.split("::");
-    switch ((0, utils_1.normalizeSuiAddress)(typeArgs[0])) {
+    let typeArgs = typeArg.split("::");
+    switch (normalizeSuiAddress(typeArgs[0])) {
         case "0x027792d9fed7f9844eb4839566001bb6f6cb4804f66aa2da6fe1ee242d896881":
             return "BTC";
         case "0xaf8cd5edc19c4512f4259f0bee101a40d41ebed738ade5874359610ef8eeced5":