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

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

@@ -1,285 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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/src/leaderboard/authority-entry.ts

@@ -1,63 +0,0 @@
-import { TransactionBlock } from "@mysten/sui.js/transactions";
-
-/**
-    public fun activate_leaderboard(
-        version: &Version,
-        registry: &mut TypusLeaderboardRegistry,
-        key: String,
-        start_ts_ms: u64,
-        end_ts_ms: u64,
-        ctx: &mut TxContext,
-    )
-*/
-export async function getActivateLeaderboardTx(
-    gasBudget: number,
-    packageId: string,
-    version: string,
-    typusLeaderboardRegistry: string,
-    key: string,
-    start_ts_ms: string,
-    end_ts_ms: string
-) {
-    let tx = new TransactionBlock();
-
-    tx.moveCall({
-        target: `${packageId}::leaderboard::activate_leaderboard`,
-        typeArguments: [],
-        arguments: [tx.object(version), tx.object(typusLeaderboardRegistry), tx.pure(key), tx.pure(start_ts_ms), tx.pure(end_ts_ms)],
-    });
-
-    tx.setGasBudget(gasBudget);
-
-    return tx;
-}
-
-/**
-    public fun deactivate_leaderboard(
-        version: &Version,
-        registry: &mut TypusLeaderboardRegistry,
-        key: String,
-        id: address,
-        ctx: &mut TxContext,
-    )
-*/
-export async function getDeactivateLeaderboardTx(
-    gasBudget: number,
-    packageId: string,
-    version: string,
-    typusLeaderboardRegistry: string,
-    key: string,
-    id: string
-) {
-    let tx = new TransactionBlock();
-
-    tx.moveCall({
-        target: `${packageId}::leaderboard::deactivate_leaderboard`,
-        typeArguments: [],
-        arguments: [tx.object(version), tx.object(typusLeaderboardRegistry), tx.pure(key), tx.pure(id)],
-    });
-
-    tx.setGasBudget(gasBudget);
-
-    return tx;
-}

package/src/leaderboard/view-function.ts

@@ -1,66 +0,0 @@
-import { TransactionBlock } from "@mysten/sui.js/transactions";
-import { SuiClient } from "@mysten/sui.js/client";
-import { BcsReader } from "@mysten/bcs";
-import { AddressFromBytes } from "../utils/tools";
-
-export interface Rankings {
-    user_score: string;
-    leaderboard: Ranks[];
-}
-export interface Ranks {
-    score: string;
-    users: string[];
-}
-export async function getRankings(input: {
-    provider: SuiClient;
-    typusPackageId: string;
-    typusEcosystemVersion: string;
-    typusLeaderboardRegistry: string;
-    key: string;
-    id: string;
-    ranks: number;
-    user: string;
-    active: boolean;
-}): Promise<Rankings> {
-    let transactionBlock = new TransactionBlock();
-    transactionBlock.moveCall({
-        target: `${input.typusPackageId}::leaderboard::get_rankings`,
-        typeArguments: [],
-        arguments: [
-            transactionBlock.pure(input.typusEcosystemVersion),
-            transactionBlock.pure(input.typusLeaderboardRegistry),
-            transactionBlock.pure(input.key),
-            transactionBlock.pure(input.id),
-            transactionBlock.pure(input.ranks),
-            transactionBlock.pure(input.user),
-            transactionBlock.pure(input.active),
-        ],
-    });
-    let results = (
-        await input.provider.devInspectTransactionBlock({
-            sender: "0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
-            transactionBlock,
-        })
-    ).results;
-    // @ts-ignore
-    let bytes = results[results.length - 1].returnValues[0][0];
-    let reader = new BcsReader(new Uint8Array(bytes));
-    let result = reader.readVec((reader, i) => {
-        if (i == 0) {
-            reader.readULEB();
-            return reader.read64();
-        } else {
-            reader.readULEB();
-            return {
-                score: reader.read64(),
-                users: reader.readVec((reader) => {
-                    return AddressFromBytes(reader.readBytes(32));
-                }),
-            };
-        }
-    });
-    return {
-        user_score: result[0],
-        leaderboard: result.slice(1),
-    } as Rankings;
-}

package/src/tails-exp-dice/api.ts

@@ -1,46 +0,0 @@
-const apiUrl = "https://us-central1-aqueous-freedom-378103.cloudfunctions.net/draw-result-1";
-
-export async function getDrawResult(
-    network: "mainnet" | "testnet",
-    packageId: string,
-    registry: string,
-    index: string,
-    amount: string,
-    guess_1: string,
-    larger_than_1: boolean,
-    guess_2: string,
-    larger_than_2: boolean,
-    vrf_input_1: number[],
-    vrf_input_2: number[]
-) {
-    const queryParams = new URLSearchParams({
-        network,
-        packageId,
-        registry,
-        index,
-        amount,
-        guess_1,
-        larger_than_1: `${larger_than_1}`,
-        guess_2,
-        larger_than_2: `${larger_than_2}`,
-    });
-
-    const vrf_input_1_string = JSON.stringify(vrf_input_1);
-    const vrf_input_2_string = JSON.stringify(vrf_input_2);
-
-    // Append the query parameters to the URL
-    const apiUrlWithParams = `${apiUrl}?${queryParams.toString()}&vrf_input_1=${vrf_input_1_string}&vrf_input_2=${vrf_input_2_string}`;
-    // console.log(apiUrlWithParams);
-
-    let response = await fetch(apiUrlWithParams, {
-        method: "GET",
-        headers: { "Content-Type": "application/json" },
-    });
-
-    // console.log(response);
-
-    if (response.ok) {
-        let data = await response.json();
-        return data;
-    }
-}