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

package/src/utils/api/sentio/reward-generated.ts

@@ -0,0 +1,392 @@
+const headers = {
+    "api-key": "tz3JJ6stG7Fux6ueRSRA5mdpC9U0lozI3",
+    "Content-Type": "application/json",
+};
+
+export async function getTotalDepositorIncentive(): Promise<TokenAmount> {
+    const apiUrl = "https://app.sentio.xyz/api/v1/analytics/typus/typus_v2/sql/execute";
+
+    const requestData = {
+        sqlQuery: {
+            sql: `
+                SELECT SUM(E.depositor_incentive_value) as incentive
+                FROM Delivery E
+            `,
+            size: 2000000,
+        },
+    };
+
+    const jsonData = JSON.stringify(requestData);
+
+    let response = await fetch(apiUrl, {
+        method: "POST",
+        headers,
+        body: jsonData,
+    });
+
+    let data = await response.json();
+
+    return { token: "SUI", total_amount: data.result.rows[0].incentive } as TokenAmount;
+}
+
+export async function getTotalPremium(): Promise<number> {
+    const apiUrl = "https://app.sentio.xyz/api/v1/insights/typus/typus_v2/query";
+
+    const requestData = {
+        timeRange: {
+            start: "now",
+            end: "now",
+            step: 3600,
+            timezone: "Europe/Paris",
+        },
+        limit: 1,
+        queries: [
+            {
+                metricsQuery: {
+                    query: "AccumulatedPremiumUSD",
+                    alias: "",
+                    id: "a",
+                    labelSelector: {},
+                    aggregate: {
+                        op: "SUM",
+                        grouping: ["chain"],
+                    },
+                    functions: [],
+                    disabled: false,
+                },
+                dataSource: "METRICS",
+                sourceName: "",
+            },
+        ],
+        formulas: [],
+    };
+
+    const jsonData = JSON.stringify(requestData);
+
+    let response = await fetch(apiUrl, {
+        method: "POST",
+        headers,
+        body: jsonData,
+    });
+
+    let data = await response.json();
+
+    return data.results[0].matrix.samples[0].values[0].value;
+}
+
+/** Returns Accumulated Rewards im USD [v1, v2] */
+export async function getAccumulatedRewardGeneratedUSD(): Promise<[number, number]> {
+    const apiUrlV1 = "https://app.sentio.xyz/api/v1/insights/typus/typus_v1/query";
+
+    const requestDataV1 = {
+        timeRange: {
+            start: "now",
+            end: "now",
+            step: 3600,
+            timezone: "Asia/Taipei",
+        },
+        limit: 1,
+        queries: [
+            {
+                metricsQuery: {
+                    query: "AccumulatedPremiumUSD",
+                    alias: "",
+                    id: "a",
+                    labelSelector: {},
+                    aggregate: {
+                        op: "SUM",
+                        grouping: [],
+                    },
+                    functions: [],
+                    disabled: false,
+                },
+                dataSource: "METRICS",
+                sourceName: "",
+            },
+        ],
+        formulas: [],
+    };
+
+    const jsonDataV1 = JSON.stringify(requestDataV1);
+
+    let responseV1 = await fetch(apiUrlV1, {
+        method: "POST",
+        headers,
+        body: jsonDataV1,
+    });
+
+    let dataV1 = await responseV1.json();
+    // console.log(dataV1.results[0].matrix.samples[0].values[0].value);
+
+    // data.results[0].matrix.samples[0].values[0].value;
+
+    const apiUrl = "https://app.sentio.xyz/api/v1/insights/typus/typus_v2/query";
+
+    const requestData = {
+        timeRange: {
+            start: "now",
+            end: "now",
+            step: 3600,
+            timezone: "Asia/Taipei",
+        },
+        limit: 1,
+        queries: [
+            {
+                metricsQuery: {
+                    query: "AccumulatedRewardGeneratedUSD",
+                    alias: "",
+                    id: "a",
+                    labelSelector: {},
+                    aggregate: {
+                        op: "SUM",
+                        grouping: [],
+                    },
+                    functions: [],
+                    disabled: false,
+                },
+                dataSource: "METRICS",
+                sourceName: "",
+            },
+        ],
+        formulas: [],
+    };
+
+    const jsonData = JSON.stringify(requestData);
+
+    let response = await fetch(apiUrl, {
+        method: "POST",
+        headers,
+        body: jsonData,
+    });
+
+    let data = await response.json();
+    // console.log(data);
+
+    return [dataV1.results[0].matrix.samples[0].values[0].value, data.results[0].matrix.samples[0].values[0].value];
+}
+
+export async function getTotalProfitSharingClaimed(): Promise<TokenAmount[]> {
+    const apiUrl = "https://app.sentio.xyz/api/v1/analytics/typus/typus_v2/sql/execute";
+
+    const requestData = {
+        sqlQuery: {
+            sql: `
+                SELECT token, SUM(amount) AS total_amount
+                FROM ClaimProfitSharing
+                GROUP BY token;
+            `,
+            size: 2000000,
+        },
+    };
+
+    const jsonData = JSON.stringify(requestData);
+
+    let response = await fetch(apiUrl, {
+        method: "POST",
+        headers,
+        body: jsonData,
+    });
+
+    let data = await response.json();
+
+    return data.result.rows as TokenAmount[];
+}
+
+import { SuiClient, SuiEvent } from "@mysten/sui.js/client";
+
+export async function getTotalProfitSharing(provider: SuiClient): Promise<TokenAmount[]> {
+    var hasNextPage = true;
+    var cursor: any | undefined = undefined;
+
+    const datas: SuiEvent[] = [];
+
+    while (hasNextPage) {
+        var result = await provider.queryEvents({
+            query: {
+                MoveEventType: `0x80ff0830313b36bb65ab927af811037f8b175d6e83c43f906b8f55d9263eea99::tails_staking::ProfitSharingEvent`,
+            },
+            order: "descending",
+            cursor,
+        });
+
+        hasNextPage = result.hasNextPage;
+        cursor = result.nextCursor;
+
+        // @ts-ignore
+        datas = datas.concat(result.data);
+    }
+
+    const tokenAmountMap = new Map<string, number>();
+
+    for (let data of datas) {
+        // @ts-ignore
+        const token = typeArgToAsset(data.parsedJson.token.name);
+        // @ts-ignore
+        const value = data.parsedJson.value;
+
+        const amount = value / 10 ** assetToDecimal(token)!;
+
+        // const week = Math.round(Number(data.timestampMs) / 24 / 3600 / 1000);
+        if (tokenAmountMap.has(token)) {
+            let sum = tokenAmountMap.get(token)!;
+            tokenAmountMap.set(token, sum + Number(amount));
+        } else {
+            tokenAmountMap.set(token, Number(amount));
+        }
+    }
+
+    const tokenAmount: TokenAmount[] = [];
+
+    for (let x of tokenAmountMap.entries()) {
+        tokenAmount.push({ token: x[0], total_amount: x[1].toString() });
+    }
+
+    return tokenAmount;
+}
+
+interface TokenAmount {
+    token: string;
+    total_amount: string;
+}
+
+/** Returns Accumulated Users [v1, v2] */
+export async function getAccumulatedUser(): Promise<number[]> {
+    const apiUrls = [
+        "https://app.sentio.xyz/api/v1/insights/typus/typus_v1/query",
+        "https://app.sentio.xyz/api/v1/insights/typus/typus_v2/query",
+    ];
+
+    const result: number[] = [];
+
+    for (let apiUrl of apiUrls) {
+        const requestData = {
+            timeRange: {
+                start: "now-1h",
+                end: "now",
+                step: 3600,
+                timezone: "Asia/Taipei",
+            },
+            limit: 1,
+            queries: [
+                {
+                    eventsQuery: {
+                        resource: {
+                            name: "",
+                            type: "EVENTS",
+                        },
+                        alias: "",
+                        id: "a",
+                        aggregation: {
+                            countUnique: {
+                                duration: {
+                                    value: 0,
+                                    unit: "day",
+                                },
+                            },
+                        },
+                        groupBy: [],
+                        limit: 1,
+                        functions: [],
+                        disabled: false,
+                    },
+                    dataSource: "EVENTS",
+                    sourceName: "",
+                },
+            ],
+            formulas: [],
+        };
+
+        const jsonData = JSON.stringify(requestData);
+
+        let response = await fetch(apiUrl, {
+            method: "POST",
+            headers,
+            body: jsonData,
+        });
+
+        let data = await response.json();
+        // console.log(data.results[0].matrix.samples[0].values[0].value);
+
+        result.push(data.results[0].matrix.samples[0].values[0].value);
+    }
+
+    return result;
+}
+
+/** Returns Accumulated Notional Volume in USD [v1, v2] */
+export async function getAccumulatedNotionalVolumeUSD(): Promise<number[]> {
+    const apiUrls = [
+        "https://app.sentio.xyz/api/v1/insights/typus/typus_v1/query",
+        "https://app.sentio.xyz/api/v1/insights/typus/typus_v2/query",
+    ];
+
+    const result: number[] = [];
+
+    for (let apiUrl of apiUrls) {
+        const requestData = {
+            timeRange: {
+                start: "now",
+                end: "now",
+                step: 3600,
+                timezone: "Asia/Taipei",
+            },
+            limit: 1,
+            queries: [
+                {
+                    metricsQuery: {
+                        query: "AccumulatedNotionalVolumeUSD",
+                        alias: "",
+                        id: "a",
+                        labelSelector: {},
+                        aggregate: {
+                            op: "SUM",
+                            grouping: [],
+                        },
+                        functions: [],
+                        disabled: false,
+                    },
+                    dataSource: "METRICS",
+                    sourceName: "",
+                },
+            ],
+            formulas: [],
+        };
+
+        const jsonData = JSON.stringify(requestData);
+
+        let response = await fetch(apiUrl, {
+            method: "POST",
+            headers,
+            body: jsonData,
+        });
+
+        let data = await response.json();
+        console.log(data.results[0]);
+
+        result.push(data.results[0].matrix.samples[0].values[0].value);
+    }
+
+    return result;
+}
+
+import configs from "../../../../config.json";
+import { assetToDecimal, typeArgToAsset } from "src/constants/token";
+
+(async () => {
+    // const res1 = await getTotalDepositorIncentive();
+    // console.log(res1);
+    // const res2 = await getTotalPremium();
+    // console.log(res2);
+    // const res12 = await getAccumulatedRewardGeneratedUSD();
+    // console.log(res12);
+    // const res3 = await getTotalProfitSharingClaimed();
+    // console.log(res3);
+    // const config = configs.MAINNET;
+    // const provider = new SuiClient({ url: config.RPC_ENDPOINT });
+    // const res4 = await getTotalProfitSharing(provider);
+    // console.log(res4);
+    // const res5 = await getAccumulatedUser();
+    // console.log(res5);
+    // const res6 = await getAccumulatedNotionalVolumeUSD();
+    // console.log(res6);
+})();

package/src/utils/load_env.ts

@@ -0,0 +1,5 @@
+import path from "path";
+import dotenv from "dotenv";
+
+// import .env file if exists
+dotenv.config({ path: path.resolve(__dirname, ".env") });

package/src/utils/mint.ts

@@ -0,0 +1,16 @@
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+
+export async function getMintTokenTx(gasBudget: number, packageId: string, registry: string, moduleName: string, amount: number) {
+    const tx = new TransactionBlock();
+    tx.moveCall({
+        target: `${packageId}::${moduleName}::mint`,
+        arguments: [tx.pure(registry), tx.pure(amount)],
+    });
+    tx.setGasBudget(gasBudget);
+
+    return tx;
+}
+
+/*
+sui client call --gas-budget 10000 --package 0xe879e96fb90a8559127091f1176a2d10bb67c6ff --module "token_btc" --function "mint" --args 0x5dce92f67eeda471369b734deac0d540b751cea6  10000
+*/

package/{dist/utils/pyth/constant.js → src/utils/pyth/constant.ts}

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.endpoint = exports.pythStateId = exports.wormholeStateId = exports.priceInfoObjectIds = exports.priceIDs = void 0;
 // You can find the IDs of prices at https://pyth.network/developers/price-feed-ids
-exports.priceIDs = {
+export const priceIDs = {
     MAINNET: {
         // Pyth EVM Stable
         SUI: "0x23d7315113f5b1d3ba7a83604c44b94d79f4fd69af77f804fc7f920a6dc65744", // SUI/USD price ID
@@ -28,7 +25,8 @@ exports.priceIDs = {
         SCA: "0xeacabc6304d11fc10a757f63286ef44415d8e91b7a1a525ae94a7ec9398b73f3", // SCA/USD price ID
     },
 };
-exports.priceInfoObjectIds = {
+
+export const priceInfoObjectIds = {
     // MAINNET: {
     //     // Pyth EVM Stable
     //     SUI: "0x23d7315113f5b1d3ba7a83604c44b94d79f4fd69af77f804fc7f920a6dc65744", // SUI/USD price ID
@@ -53,18 +51,21 @@ exports.priceInfoObjectIds = {
         SCA: "0xf96e3c4b7d74efbde9df5b669188421196e6164adf6fbaaa92903c42569807c8",
     },
 };
+
 // Get the state IDs of the Pyth and Wormhole contracts from
 // https://docs.pyth.network/price-feeds/contract-addresses/sui
-exports.wormholeStateId = {
+export const wormholeStateId = {
     MAINNET: "0x5306f64e312b581766351c07af79c72fcb1cd25147157fdc2f8ad76de9a3fb6a",
     TESTNET: "0x31358d198147da50db32eda2562951d53973a0c0ad5ed738e9b17d88b213d790",
 };
-exports.pythStateId = {
+export const pythStateId = {
     MAINNET: "0x1f9310238ee9298fb703c3419030b35b22bb1cc37113e3bb5007c99aec79e5b8",
     TESTNET: "0x243759059f4c3111179da5878c12f68d612c21a8d54d85edc86164bb18be1c7c",
 };
+
 // Get the Stable Hermes service URL from https://docs.pyth.network/price-feeds/api-instances-and-providers/hermes
-exports.endpoint = {
+
+export const endpoint = {
     MAINNET: "https://hermes.pyth.network",
     TESTNET: "https://hermes-beta.pyth.network",
 };

package/src/utils/pyth/pythClient.ts

@@ -0,0 +1,52 @@
+import { SuiPriceServiceConnection, SuiPythClient } from "@pythnetwork/pyth-sui-js";
+import { pythStateId, wormholeStateId, priceIDs, priceInfoObjectIds } from "./constant";
+import { SuiClient } from "@mysten/sui.js/client";
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+import { TOKEN } from "src/constants/token";
+import { ObjectId } from "@pythnetwork/pyth-sui-js/lib/client";
+
+export declare class PythClient {
+    network: "MAINNET" | "TESTNET";
+    client: SuiPythClient;
+    connection: SuiPriceServiceConnection;
+}
+
+export function createPythClient(provider: any, network: "MAINNET" | "TESTNET"): PythClient {
+    const client = new SuiPythClient(provider, pythStateId[network], wormholeStateId[network]);
+    const connection = new SuiPriceServiceConnection("https://hermes-beta.pyth.network");
+    const pythClient = { network, client, connection };
+    return pythClient;
+}
+
+export async function updatePyth(pythClient: PythClient, tx: TransactionBlock, tokens: string[]): Promise<ObjectId[]> {
+    const _priceIDs = tokens.map((token) => priceIDs[pythClient.network][token]);
+    // console.log(_priceIDs);
+
+    const priceFeedUpdateData = await pythClient.connection.getPriceFeedsUpdateData(_priceIDs);
+
+    // @ts-ignore
+    const priceInfoObjectIds = await pythClient.client.updatePriceFeeds(tx, priceFeedUpdateData, _priceIDs);
+
+    return priceInfoObjectIds;
+}
+
+export function updateOracleWithPyth(
+    pythClient: PythClient,
+    tx: TransactionBlock,
+    oraclePackage: string,
+    typusOracle: string,
+    baseToken: TOKEN,
+    quoteToken: TOKEN
+) {
+    tx.moveCall({
+        target: `${oraclePackage}::oracle::update_with_pyth`,
+        typeArguments: [],
+        arguments: [
+            tx.object(typusOracle),
+            tx.object(pythStateId[pythClient.network]),
+            tx.object(priceInfoObjectIds[pythClient.network][baseToken]),
+            tx.object(priceInfoObjectIds[pythClient.network][quoteToken]),
+            tx.object("0x6"),
+        ],
+    });
+}

package/src/utils/tools.ts

@@ -0,0 +1,38 @@
+import BigNumber from "bignumber.js";
+
+export function U64FromBytes(x) {
+    var u64 = BigInt(0);
+    for (var i = 0; i < x.length; i++) {
+        u64 = u64 << BigInt(8);
+        u64 += BigInt(x[i]);
+    }
+    return u64;
+}
+
+export function AddressFromBytes(x) {
+    var address = "0x";
+    for (var i = 0; i < x.length; i++) {
+        address = address.concat(x[i].toString(16).padStart(2, "0"));
+    }
+    return address;
+}
+
+export const insertAt = (str: string, sub: string, pos: number) => `${str.slice(0, pos)}${sub}${str.slice(pos)}`;
+
+export const checkNumber = (str: any) => {
+    if (typeof str != "string") return false; // we only process strings!
+    return (
+        // @ts-ignore
+        !isNaN(str) && // use type coercion to parse the _entirety_ of the string (`parseFloat` alone does not do this)...
+        !isNaN(parseFloat(str))
+    ); // ...and ensure strings of whitespace fail
+};
+
+export const countFloating = (value: number | BigNumber) => {
+    let num = BigNumber(value).toFixed().replace(/,/g, "");
+    if (value instanceof BigNumber) {
+        num = value.toFixed().replace(/,/g, "");
+    }
+    if (!num.includes(".")) return 0;
+    return num.split(".")[1].length;
+};

package/dist/_dependencies/source/0x1/ascii/structs.d.ts

@@ -1,82 +0,0 @@
-import * as reified from "../../../../_framework/reified";
-import { PhantomReified, Reified, StructClass, ToField, ToTypeStr, Vector } from "../../../../_framework/reified";
-import { FieldsWithTypes } from "../../../../_framework/util";
-import { SuiClient, SuiParsedData } from "@mysten/sui.js/client";
-export declare function isChar(type: string): boolean;
-export interface CharFields {
-    byte: ToField<"u8">;
-}
-export type CharReified = Reified<Char, CharFields>;
-export declare class Char implements StructClass {
-    static readonly $typeName = "0x1::ascii::Char";
-    static readonly $numTypeParams = 0;
-    readonly $typeName = "0x1::ascii::Char";
-    readonly $fullTypeName: "0x1::ascii::Char";
-    readonly $typeArgs: [];
-    readonly byte: ToField<"u8">;
-    private constructor();
-    static reified(): CharReified;
-    static get r(): reified.StructClassReified<Char, CharFields>;
-    static phantom(): PhantomReified<ToTypeStr<Char>>;
-    static get p(): reified.PhantomReified<"0x1::ascii::Char">;
-    static get bcs(): import("@mysten/bcs").BcsType<{
-        byte: number;
-    }, {
-        byte: number;
-    }>;
-    static fromFields(fields: Record<string, any>): Char;
-    static fromFieldsWithTypes(item: FieldsWithTypes): Char;
-    static fromBcs(data: Uint8Array): Char;
-    toJSONField(): {
-        byte: number;
-    };
-    toJSON(): {
-        byte: number;
-        $typeName: string;
-        $typeArgs: [];
-    };
-    static fromJSONField(field: any): Char;
-    static fromJSON(json: Record<string, any>): Char;
-    static fromSuiParsedData(content: SuiParsedData): Char;
-    static fetch(client: SuiClient, id: string): Promise<Char>;
-}
-export declare function isString(type: string): boolean;
-export interface StringFields {
-    bytes: ToField<Vector<"u8">>;
-}
-export type StringReified = Reified<String, StringFields>;
-export declare class String implements StructClass {
-    static readonly $typeName = "0x1::ascii::String";
-    static readonly $numTypeParams = 0;
-    readonly $typeName = "0x1::ascii::String";
-    readonly $fullTypeName: "0x1::ascii::String";
-    readonly $typeArgs: [];
-    readonly bytes: ToField<Vector<"u8">>;
-    private constructor();
-    static reified(): StringReified;
-    static get r(): reified.StructClassReified<String, StringFields>;
-    static phantom(): PhantomReified<ToTypeStr<String>>;
-    static get p(): reified.PhantomReified<"0x1::ascii::String">;
-    static get bcs(): import("@mysten/bcs").BcsType<{
-        bytes: number[];
-    }, {
-        bytes: Iterable<number> & {
-            length: number;
-        };
-    }>;
-    static fromFields(fields: Record<string, any>): String;
-    static fromFieldsWithTypes(item: FieldsWithTypes): String;
-    static fromBcs(data: Uint8Array): String;
-    toJSONField(): {
-        bytes: number[];
-    };
-    toJSON(): {
-        bytes: number[];
-        $typeName: string;
-        $typeArgs: [];
-    };
-    static fromJSONField(field: any): String;
-    static fromJSON(json: Record<string, any>): String;
-    static fromSuiParsedData(content: SuiParsedData): String;
-    static fetch(client: SuiClient, id: string): Promise<String>;
-}