@typus/typus-sdk 1.4.3-c → 1.4.3-e

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/src/typus-perp/init.ts

@@ -0,0 +1,96 @@
+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);
+    loader.register(admin.SendFeeEvent);
+    loader.register(admin.Version);
+    loader.register(treasuryCaps.TreasuryCaps);
+    loader.register(tlp.LpRegistry);
+    loader.register(tlp.TLP);
+    loader.register(oracle.PythPrice);
+    loader.register(oracle.PythPriceInfoObject);
+    loader.register(lpPool.Config);
+    loader.register(lpPool.State);
+    loader.register(lpPool.AddLiquidityTokenEvent);
+    loader.register(lpPool.BurnLpEvent);
+    loader.register(lpPool.LiquidityPool);
+    loader.register(lpPool.LiquidityPoolInfo);
+    loader.register(lpPool.MarginConfig);
+    loader.register(lpPool.MintLpEvent);
+    loader.register(lpPool.NewLiquidityPoolEvent);
+    loader.register(lpPool.Registry);
+    loader.register(lpPool.ResumePoolEvent);
+    loader.register(lpPool.ResumeTokenPoolEvent);
+    loader.register(lpPool.SpotConfig);
+    loader.register(lpPool.SuspendPoolEvent);
+    loader.register(lpPool.SuspendTokenPoolEvent);
+    loader.register(lpPool.SwapEvent);
+    loader.register(lpPool.TokenPool);
+    loader.register(lpPool.UpdateLiquidityValueEvent);
+    loader.register(lpPool.UpdateMarginConfigEvent);
+    loader.register(lpPool.UpdateSpotConfigEvent);
+    loader.register(symbol.Symbol);
+    loader.register(position.OrderFilledEvent);
+    loader.register(position.Position);
+    loader.register(position.RealizeFundingEvent);
+    loader.register(position.RealizedPnlEvent);
+    loader.register(position.RemovePositionEvent);
+    loader.register(position.TradingOrder);
+    loader.register(stakePool.UnsubscribeEvent);
+    loader.register(stakePool.ActivateIncentiveTokenEvent);
+    loader.register(stakePool.AddIncentiveTokenEvent);
+    loader.register(stakePool.DeactivateIncentiveTokenEvent);
+    loader.register(stakePool.DeactivatingShares);
+    loader.register(stakePool.DepositIncentiveEvent);
+    loader.register(stakePool.HarvestPerUserShareEvent);
+    loader.register(stakePool.Incentive);
+    loader.register(stakePool.IncentiveConfig);
+    loader.register(stakePool.IncentiveInfo);
+    loader.register(stakePool.LpUserShare);
+    loader.register(stakePool.NewStakePoolEvent);
+    loader.register(stakePool.RemoveIncentiveTokenEvent);
+    loader.register(stakePool.StakeEvent);
+    loader.register(stakePool.StakePool);
+    loader.register(stakePool.StakePoolConfig);
+    loader.register(stakePool.StakePoolInfo);
+    loader.register(stakePool.StakePoolRegistry);
+    loader.register(stakePool.UnstakeEvent);
+    loader.register(stakePool.UpdateIncentiveConfigEvent);
+    loader.register(stakePool.UpdateUnlockCountdownTsMsEvent);
+    loader.register(stakePool.WithdrawIncentiveEvent);
+    loader.register(trading.AddTradingSymbolEvent);
+    loader.register(trading.CancelTradingOrderEvent);
+    loader.register(trading.CreateTradingOrderEvent);
+    loader.register(trading.CreateTradingOrderWithBidReceiptsEvent);
+    loader.register(trading.IncreaseCollateralEvent);
+    loader.register(trading.LinkedOrdersInfo);
+    loader.register(trading.LiquidateEvent);
+    loader.register(trading.ManagerReducePosition);
+    loader.register(trading.MarketConfig);
+    loader.register(trading.MarketInfo);
+    loader.register(trading.MarketRegistry);
+    loader.register(trading.Markets);
+    loader.register(trading.MatchTradingOrderEvent);
+    loader.register(trading.NewMarketsEvent);
+    loader.register(trading.ReleaseCollateralEvent);
+    loader.register(trading.ResumeMarketEvent);
+    loader.register(trading.ResumeTradingSymbolEvent);
+    loader.register(trading.SuspendMarketEvent);
+    loader.register(trading.SuspendTradingSymbolEvent);
+    loader.register(trading.SymbolMarket);
+    loader.register(trading.USD);
+    loader.register(trading.UpdateFundingRateEvent);
+    loader.register(trading.UpdateMarketConfigEvent);
+    loader.register(trading.UpdateProtocolFeeShareBpEvent);
+}