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

package/src/typus-perp/fetch.ts

@@ -0,0 +1,253 @@
+import { SuiClient } from "@mysten/sui.js/client";
+import { LiquidityPool, Registry } from "./lp-pool/structs";
+import { MarketRegistry, Markets, SymbolMarket } from "./trading/structs";
+import { getUserOrders as _getUserOrders, getUserPositions as _getUserPositions, getEstimatedLiquidationPrice } from "./trading/functions";
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+import { readVecOrder, readVecPosition, readVecShares } from "./readVec";
+import { TradingOrder, Position } from "./position/structs";
+import { getUserShares } from "./stake-pool/functions";
+import { LpUserShare, StakePool } from "./stake-pool/structs";
+import { CLOCK } from "src/constants";
+import { tokenType, typeArgToToken } from "src/constants/token";
+import { priceInfoObjectIds, pythStateId } from "src/utils/pyth/constant";
+import { NETWORK } from ".";
+import { PythClient, updatePyth } from "src/utils/pyth/pythClient";
+import { BcsReader, bcs } from "@mysten/bcs";
+
+export async function getLpPools(
+    provider: SuiClient,
+    config: {
+        REGISTRY: {
+            LP_POOL_REGISTRY: string;
+            LIQUIDITY_POOL_REGISTRY: string;
+        };
+    }
+): Promise<LiquidityPool[]> {
+    // const lpPoolRegistry = await Registry.fetch(provider, config.REGISTRY.LP_POOL_REGISTRY);
+    // console.log(lpPoolRegistry);
+
+    const dynamicFields = await provider.getDynamicFields({
+        parentId: config.REGISTRY.LIQUIDITY_POOL_REGISTRY,
+    });
+
+    const lpPools: LiquidityPool[] = [];
+
+    for (const field of dynamicFields.data) {
+        const lpPool = await LiquidityPool.fetch(provider, field.objectId);
+        // console.log(lpPool);
+        lpPools.push(lpPool);
+    }
+
+    return lpPools;
+}
+
+export async function getStakePools(
+    provider: SuiClient,
+    config: {
+        REGISTRY: {
+            STAKE_POOL_REGISTRY: string;
+        };
+    }
+): Promise<StakePool[]> {
+    const dynamicFields = await provider.getDynamicFields({
+        parentId: config.REGISTRY.STAKE_POOL_REGISTRY,
+    });
+
+    const stakePools: StakePool[] = [];
+
+    for (const field of dynamicFields.data) {
+        const stakePool = await StakePool.fetch(provider, field.objectId);
+        // console.log(stakePool);
+        stakePools.push(stakePool);
+    }
+
+    return stakePools;
+}
+
+export async function getMarkets(provider: SuiClient, config: { REGISTRY: { MARKET_REGISTRY: string } }): Promise<Markets[]> {
+    // const marketRegistry = await MarketRegistry.fetch(provider, config.REGISTRY.MARKET_REGISTRY);
+    // console.log(marketRegistry);
+    // MarketRegistry {
+    //   '$typeName': '0x1a05edb0e5e670196de98fbbf544180d129dd4ec11c3c57f742badf0304650d::trading::MarketRegistry',
+    //   '$fullTypeName': '0x1a05edb0e5e670196de98fbbf544180d129dd4ec11c3c57f742badf0304650d::trading::MarketRegistry',
+    //   '$typeArgs': [],
+    //   id: '0x6e11e468b50b1665b930020ea8223bdcc7c86024f85d51021a06dd4ee0e27905',
+    //   referralRegistry: '0xd5c597256ac6acac8cbd52369b4fd87712b964686266f2e790b4f381edfb2b89',
+    //   numMarket: 1n,
+    //   u64Padding: []
+    // }
+
+    const dynamicFields = await provider.getDynamicFields({
+        parentId: config.REGISTRY.MARKET_REGISTRY,
+    });
+
+    const markets: Markets[] = [];
+
+    for (const field of dynamicFields.data) {
+        const market = await Markets.fetch(provider, field.objectId);
+        // console.log(market);
+        markets.push(market);
+    }
+    return markets;
+}
+
+export async function getSymbolMarkets(provider: SuiClient, market: Markets): Promise<Map<string, SymbolMarket>> {
+    const symbolMarkets = new Map<string, SymbolMarket>();
+
+    const dynamicFields = await provider.getDynamicFields({
+        parentId: market.symbolMarkets.id,
+    });
+
+    for (const field of dynamicFields.data) {
+        const symbolMarket = await SymbolMarket.fetch(provider, field.objectId);
+        // @ts-ignore
+        const key = field.name.value.name;
+        // console.log(key);
+        // console.log(symbolMarket);
+        symbolMarkets.set(key, symbolMarket);
+    }
+
+    return symbolMarkets;
+}
+
+export async function getUserOrders(
+    provider: SuiClient,
+    config: { OBJECT: { TYPUS_PERP_VERSION: string }; REGISTRY: { MARKET_REGISTRY: string } },
+    user: string
+) {
+    let tx = new TransactionBlock();
+
+    _getUserOrders(tx, {
+        version: config.OBJECT.TYPUS_PERP_VERSION,
+        registry: config.REGISTRY.MARKET_REGISTRY,
+        marketIndex: BigInt(0),
+        user,
+    });
+
+    let res = await provider.devInspectTransactionBlock({ sender: user, transactionBlock: tx });
+    // console.log(res);
+
+    // @ts-ignore
+    const returnValues = res.results[0].returnValues[0][0];
+    // console.log(returnValues);
+
+    const orders: TradingOrder[] = readVecOrder(Uint8Array.from(returnValues));
+    // console.log(orders);
+    return orders;
+}
+
+export async function getUserPositions(
+    provider: SuiClient,
+    config: { OBJECT: { TYPUS_PERP_VERSION: string }; REGISTRY: { MARKET_REGISTRY: string } },
+    user: string
+) {
+    let tx = new TransactionBlock();
+
+    _getUserPositions(tx, {
+        version: config.OBJECT.TYPUS_PERP_VERSION,
+        registry: config.REGISTRY.MARKET_REGISTRY,
+        marketIndex: BigInt(0),
+        user,
+    });
+
+    let res = await provider.devInspectTransactionBlock({ sender: user, transactionBlock: tx });
+    // console.log(res);
+
+    // @ts-ignore
+    const returnValues = res.results[0].returnValues[0][0];
+    // console.log(returnValues);
+
+    const positions: Position[] = readVecPosition(Uint8Array.from(returnValues));
+    // console.log(positions);
+    return positions;
+}
+
+export async function getUserStake(
+    provider: SuiClient,
+    config: { REGISTRY: { STAKE_POOL_REGISTRY: string } },
+    user: string
+): Promise<LpUserShare[]> {
+    let tx = new TransactionBlock();
+
+    getUserShares(tx, {
+        registry: config.REGISTRY.STAKE_POOL_REGISTRY,
+        index: BigInt(0),
+        user,
+    });
+
+    let res = await provider.devInspectTransactionBlock({ sender: user, transactionBlock: tx });
+    // console.log(res);
+
+    if (res.results) {
+        // @ts-ignore
+        const returnValues = res.results[0].returnValues[0][0];
+        // console.log(returnValues);
+
+        const stake: LpUserShare[] = readVecShares(Uint8Array.from(returnValues));
+        // console.log(stake);
+        // console.log(stake[0].deactivatingShares);
+        // console.log(stake[0].lastIncentivePriceIndex);
+        return stake;
+    } else {
+        return [];
+    }
+}
+
+export async function getLiquidationPrice(
+    provider: SuiClient,
+    config: {
+        OBJECT: { TYPUS_PERP_VERSION: string };
+        REGISTRY: {
+            LP_POOL_REGISTRY: string;
+            MARKET_REGISTRY: string;
+        };
+    },
+    input: {
+        pythClient: PythClient;
+        positions: Position[];
+        user: string;
+    }
+) {
+    let tx = new TransactionBlock();
+
+    const pythTokens: string[] = [];
+
+    for (let position of input.positions) {
+        // parse from Position
+        const TOKEN = typeArgToToken(position.collateralToken.name);
+        const BASE_TOKEN = typeArgToToken(position.symbol.baseToken.name);
+        pythTokens.push(TOKEN);
+        pythTokens.push(BASE_TOKEN);
+    }
+
+    await updatePyth(input.pythClient, tx, Array.from(new Set(pythTokens)));
+
+    for (let position of input.positions) {
+        // parse from Position
+        const TOKEN = typeArgToToken(position.collateralToken.name);
+        const BASE_TOKEN = typeArgToToken(position.symbol.baseToken.name);
+
+        const cToken = tokenType[NETWORK][TOKEN];
+        const baseToken = tokenType[NETWORK][BASE_TOKEN];
+
+        getEstimatedLiquidationPrice(tx, [cToken, baseToken], {
+            version: config.OBJECT.TYPUS_PERP_VERSION,
+            registry: config.REGISTRY.MARKET_REGISTRY,
+            poolRegistry: config.REGISTRY.LP_POOL_REGISTRY,
+            marketIndex: BigInt(0),
+            poolIndex: BigInt(0),
+            pythState: pythStateId[NETWORK],
+            oracleCToken: priceInfoObjectIds[NETWORK][TOKEN],
+            oracleTradingSymbol: priceInfoObjectIds[NETWORK][BASE_TOKEN],
+            clock: CLOCK,
+            positionId: position.positionId,
+        });
+    }
+
+    let res = await provider.devInspectTransactionBlock({ sender: input.user, transactionBlock: tx });
+    // console.log(res);
+
+    const prices = res.results?.slice(-input.positions.length).map((x) => bcs.u64().parse(Uint8Array.from(x.returnValues![0][0])));
+    // console.log(prices);
+    return prices;
+}

package/src/typus-perp/index.ts

@@ -0,0 +1,9 @@
+import configs from "../../config.json";
+import path from "path";
+import dotenv from "dotenv";
+// import .env file if exists
+dotenv.config({ path: path.resolve(__dirname, ".env") });
+
+export const NETWORK = process.env.CLUSTER == "mainnet" ? "MAINNET" : "TESTNET";
+export const PACKAGE_ID = process.env.CLUSTER == "mainnet" ? configs.MAINNET.PACKAGE_ORIGIN.PERP : configs.TESTNET.PACKAGE.PERP;
+export const PUBLISHED_AT = process.env.CLUSTER == "mainnet" ? configs.MAINNET.PACKAGE.PERP : configs.TESTNET.PACKAGE.PERP;

package/{dist/typus-perp/init.js → src/typus-perp/init.ts}

@@ -1,39 +1,15 @@
-"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerClasses = registerClasses;
-var admin = __importStar(require("./admin/structs"));
-var lpPool = __importStar(require("./lp-pool/structs"));
-var oracle = __importStar(require("./oracle/structs"));
-var position = __importStar(require("./position/structs"));
-var stakePool = __importStar(require("./stake-pool/structs"));
-var symbol = __importStar(require("./symbol/structs"));
-var tlp = __importStar(require("./tlp/structs"));
-var trading = __importStar(require("./trading/structs"));
-var treasuryCaps = __importStar(require("./treasury-caps/structs"));
-function registerClasses(loader) {
+import * as admin from "./admin/structs";
+import * as lpPool from "./lp-pool/structs";
+import * as oracle from "./oracle/structs";
+import * as position from "./position/structs";
+import * as stakePool from "./stake-pool/structs";
+import * as symbol from "./symbol/structs";
+import * as tlp from "./tlp/structs";
+import * as trading from "./trading/structs";
+import * as treasuryCaps from "./treasury-caps/structs";
+import { StructClassLoader } from "../_framework/loader";
+
+export function registerClasses(loader: StructClassLoader) {
     loader.register(admin.FeeInfo);
     loader.register(admin.FeePool);
     loader.register(admin.ManagerCap);