@typus/typus-perp-sdk 1.1.30 → 1.1.31-codegen

package/dist/src/client.d.ts

@@ -0,0 +1,27 @@
+import { SuiGraphQLClient } from "@mysten/sui/graphql";
+import { SuiGrpcClient } from "@mysten/sui/grpc";
+import { DevInspectTransactionBlockParams, ExecuteTransactionBlockParams, GetCoinsParams, GetDynamicFieldsParams, GetObjectParams, GetOwnedObjectsParams, MultiGetObjectsParams, QueryEventsParams, SuiClient } from "@mysten/sui/client";
+import { PythClient, TypusConfig } from "@typus/typus-sdk/dist/src/utils";
+import type { Experimental_SuiClientTypes } from "@mysten/sui/experimental";
+export type Network = "MAINNET" | "TESTNET";
+export declare class TypusClient {
+    jsonRpcClient: SuiClient;
+    gRpcClient: SuiGrpcClient;
+    graphQLClient: SuiGraphQLClient;
+    pythClient: PythClient;
+    config: TypusConfig;
+    constructor(config: TypusConfig, mvr?: Experimental_SuiClientTypes.MvrOptions);
+    getCoins(params: GetCoinsParams): Promise<import("@mysten/sui/client").PaginatedCoins>;
+    getObject(params: GetObjectParams): Promise<import("@mysten/sui/client").SuiObjectResponse>;
+    getOwnedObjects(params: GetOwnedObjectsParams): Promise<import("@mysten/sui/client").PaginatedObjectsResponse>;
+    getDynamicFields(params: GetDynamicFieldsParams): Promise<import("@mysten/sui/client").DynamicFieldPage>;
+    multiGetObjects(params: MultiGetObjectsParams): Promise<import("@mysten/sui/client").SuiObjectResponse[]>;
+    devInspectTransactionBlock(params: DevInspectTransactionBlockParams): Promise<import("@mysten/sui/client").DevInspectResults>;
+    executeTransactionBlock(params: ExecuteTransactionBlockParams): Promise<import("@mysten/sui/client").SuiTransactionBlockResponse>;
+    signAndExecuteTransaction(params: any): Promise<import("@mysten/sui/client").SuiTransactionBlockResponse>;
+    queryEvents(params: QueryEventsParams): Promise<import("@mysten/sui/client").PaginatedEvents>;
+    getObjectBcs(objectId: string): Promise<Uint8Array<ArrayBufferLike> | undefined>;
+    batchGetObjectsBcs(objectIds: string[]): Promise<(Uint8Array<ArrayBufferLike> | undefined)[]>;
+    getDynamicFieldsBcs(parent: string): Promise<Uint8Array<ArrayBufferLike>[]>;
+    getDynamicObjectFieldsBcs(parent: string): Promise<Uint8Array<ArrayBufferLike>[]>;
+}

package/dist/src/client.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypusClient = void 0;
+const graphql_1 = require("@mysten/sui/graphql");
+const grpc_1 = require("@mysten/sui/grpc");
+const client_1 = require("@mysten/sui/client");
+const utils_1 = require("@typus/typus-sdk/dist/src/utils");
+const src_1 = require("../src");
+class TypusClient {
+    // user: string;
+    constructor(config, mvr) {
+        this.config = config;
+        const network = config.network.toLowerCase();
+        this.jsonRpcClient = new client_1.SuiClient({
+            network: network,
+            url: config.rpcEndpoint,
+            mvr: {
+                overrides: {
+                    packages: {
+                        "@typus/perp": src_1.PERP_PUBLISHED_AT,
+                        "@typus/stake-pool": src_1.STAKE_PUBLISHED_AT,
+                    },
+                    // types: {
+                    //     "@typus/perp": PERP_PACKAGE_ID,
+                    //     "@typus/stake-pool": STAKE_PACKAGE_ID,
+                    // },
+                },
+            },
+        });
+        this.gRpcClient = new grpc_1.SuiGrpcClient({
+            network: network,
+            baseUrl: `https://fullnode.${network}.sui.io:443`,
+        });
+        this.graphQLClient = new graphql_1.SuiGraphQLClient({
+            url: `https://graphql.${network}.sui.io/graphql`,
+        });
+        this.pythClient = (0, utils_1.createPythClient)(this.jsonRpcClient, this.config.network);
+    }
+    getCoins(params) {
+        return this.jsonRpcClient.getCoins(params);
+    }
+    getObject(params) {
+        return this.jsonRpcClient.getObject(params);
+    }
+    getOwnedObjects(params) {
+        return this.jsonRpcClient.getOwnedObjects(params);
+    }
+    getDynamicFields(params) {
+        return this.jsonRpcClient.getDynamicFields(params);
+    }
+    multiGetObjects(params) {
+        return this.jsonRpcClient.multiGetObjects(params);
+    }
+    devInspectTransactionBlock(params) {
+        return this.jsonRpcClient.devInspectTransactionBlock(params);
+    }
+    executeTransactionBlock(params) {
+        return this.jsonRpcClient.executeTransactionBlock(params);
+    }
+    signAndExecuteTransaction(params) {
+        return this.jsonRpcClient.signAndExecuteTransaction(params);
+    }
+    queryEvents(params) {
+        return this.jsonRpcClient.queryEvents(params);
+    }
+    // gRPC
+    async getObjectBcs(objectId) {
+        const x = await this.gRpcClient.ledgerService.getObject({ objectId, readMask: { paths: ["contents"] } });
+        return x.response.object?.contents?.value;
+    }
+    async batchGetObjectsBcs(objectIds) {
+        let requests = objectIds.map((objectId) => {
+            return {
+                objectId: objectId,
+            };
+        });
+        const x = await this.gRpcClient.ledgerService.batchGetObjects({
+            requests,
+            readMask: { paths: ["contents"] },
+        });
+        return x.response.objects.map((x_1) => {
+            if (x_1.result.oneofKind === "object") {
+                return x_1.result.object.contents?.value;
+            }
+            else if (x_1.result.oneofKind === "error") {
+                console.error(x_1.result.error);
+            }
+            else {
+                console.warn("undefined case");
+            }
+        });
+    }
+    async getDynamicFieldsBcs(parent) {
+        const x = await this.gRpcClient.stateService.listDynamicFields({ parent, readMask: { paths: ["field_object"] } });
+        return x.response.dynamicFields.map((x_1) => {
+            // console.log(x_1.fieldObject?.contents?.value!);
+            return x_1.fieldObject?.contents?.value;
+        });
+    }
+    async getDynamicObjectFieldsBcs(parent) {
+        const x = await this.gRpcClient.stateService.listDynamicFields({ parent, readMask: { paths: ["child_object"] } });
+        return x.response.dynamicFields.map((x_1) => {
+            // console.log(x_1.childObject?.contents?.value!);
+            return x_1.childObject?.contents?.value;
+        });
+    }
+}
+exports.TypusClient = TypusClient;

package/dist/src/fetch.d.ts

@@ -1,43 +1,123 @@
-import { Markets, SymbolMarket } from "./typus_perp/trading/structs";
-import { DeactivatingShares, LiquidityPool } from "./typus_perp/lp-pool/structs";
-import { TradingOrder, Position } from "./typus_perp/position/structs";
-import { LpUserShare, StakePool } from "./typus_stake_pool/stake-pool/structs";
 import { TOKEN } from "@typus/typus-sdk/dist/src/constants";
-import { PythClient, TypusConfig } from "@typus/typus-sdk/dist/src/utils";
-import { TLP_TOKEN } from ".";
-import { TypusBidReceipt } from "./_dependencies/source/0xb4f25230ba74837d8299e92951306100c4a532e8c48cc3d8828abe9b91c8b274/vault/structs";
-export declare function getLpPools(config: TypusConfig): Promise<LiquidityPool[]>;
-export declare function getLpPool(config: TypusConfig, objectId?: string): Promise<LiquidityPool>;
-export declare function getStakePools(config: TypusConfig): Promise<StakePool[]>;
-export declare function getStakePool(config: TypusConfig, objectId?: string): Promise<StakePool>;
+import { Markets, SymbolMarket } from "./generated/typus_perp/trading";
+import { DeactivatingShares } from "./generated/typus_perp/lp_pool";
+import { Position } from "./generated/typus_perp/position";
+import { LiquidityPool } from "./generated/typus_perp/lp_pool";
+import { LpUserShare, StakePool } from "./generated/typus_stake_pool/stake_pool";
+import { TypusBidReceipt } from "./generated/typus_perp/deps/typus_framework/vault";
+import { TypusClient } from "../src/client";
+export declare function getLpPools(client: TypusClient): Promise<(typeof LiquidityPool.$inferType)[]>;
+export declare function getLpPool(client: TypusClient, objectId: string): Promise<typeof LiquidityPool.$inferType>;
+export declare function getStakePools(client: TypusClient): Promise<(typeof StakePool.$inferType)[]>;
+export declare function getStakePool(client: TypusClient, objectId: string): Promise<typeof StakePool.$inferType>;
 export interface MarketsData {
-    markets: Markets;
-    symbolMarkets: SymbolMarket[];
+    markets: typeof Markets.$inferType;
+    symbolMarkets: (typeof SymbolMarket.$inferType)[];
 }
-export declare function getMarkets(config: TypusConfig, input: {
+export declare function getMarkets(client: TypusClient, input: {
     indexes: string[];
 }): Promise<MarketsData[]>;
-export declare function getUserOrders(config: TypusConfig, user: string): Promise<TradingOrder[]>;
-export declare function getUserPositions(config: TypusConfig, user: string): Promise<Position[]>;
-export declare function parseOptionBidReceipts(positions: Position[]): (TypusBidReceipt | null)[];
-/**
- * @returns [lpShare, incentives]
- */
-export declare function getUserStake(config: TypusConfig, user: string): Promise<[LpUserShare, string[]] | null>;
+export declare function getUserOrders(client: TypusClient, input: {
+    user: string;
+    indexes: string[];
+}): Promise<{
+    id: {
+        id: string;
+    };
+    create_ts_ms: string;
+    order_id: string;
+    linked_position_id: string | null;
+    user: string;
+    collateral_token: {
+        name: string;
+    };
+    collateral_token_decimal: string;
+    symbol: {
+        base_token: {
+            name: string;
+        };
+        quote_token: {
+            name: string;
+        };
+    };
+    leverage_mbp: string;
+    reduce_only: boolean;
+    is_long: boolean;
+    is_stop_order: boolean;
+    size: string;
+    size_decimal: string;
+    trigger_price: string;
+    oracle_price_when_placing: string;
+    u64_padding: string[];
+}[]>;
+export declare function getUserPositions(client: TypusClient, input: {
+    user: string;
+    indexes: string[];
+}): Promise<{
+    id: {
+        id: string;
+    };
+    create_ts_ms: string;
+    position_id: string;
+    linked_order_ids: string[];
+    linked_order_prices: string[];
+    user: string;
+    is_long: boolean;
+    size: string;
+    size_decimal: string;
+    collateral_token: {
+        name: string;
+    };
+    collateral_token_decimal: string;
+    symbol: {
+        base_token: {
+            name: string;
+        };
+        quote_token: {
+            name: string;
+        };
+    };
+    collateral_amount: string;
+    reserve_amount: string;
+    average_price: string;
+    entry_borrow_index: string;
+    entry_funding_rate_index_sign: boolean;
+    entry_funding_rate_index: string;
+    unrealized_loss: string;
+    unrealized_funding_sign: boolean;
+    unrealized_funding_fee: string;
+    unrealized_trading_fee: string;
+    unrealized_borrow_fee: string;
+    unrealized_rebate: string;
+    option_collateral_info: {
+        index: string;
+        bid_token: {
+            name: string;
+        };
+        bid_receipts_bcs: number[][];
+    } | null;
+    u64_padding: string[];
+}[]>;
+export declare function parseOptionBidReceipts(positions: (typeof Position.$inferType)[]): (typeof TypusBidReceipt.$inferType | null)[];
 /**
- * @returns [lpShare, incentives]
+ * @returns [lpShare, incentives][]
  */
-export declare function getUserStakeById(config: TypusConfig, userShareId: string): Promise<[LpUserShare, string[]] | null>;
+export declare function getUserStake(client: TypusClient, input: {
+    user: string;
+    indexes: string[];
+}): Promise<[typeof LpUserShare.$inferType, string[]][]>;
 /**
  * @returns deactivatingShares[]
  */
-export declare function getDeactivatingShares(config: TypusConfig, user: string): Promise<DeactivatingShares<typeof TLP_TOKEN>[]>;
+export declare function getDeactivatingShares(client: TypusClient, input: {
+    user: string;
+    indexes: string[];
+}): Promise<(typeof DeactivatingShares.$inferType)[]>;
 /**
  * @returns [liquidationPrice, pnl(in USD)]
  */
-export declare function getLiquidationPriceAndPnl(config: TypusConfig, pythClient: PythClient, input: {
-    positions: Position[];
-    user: string;
+export declare function getLiquidationPriceAndPnl(client: TypusClient, input: {
+    positions: (typeof Position.$inferType)[];
 }): Promise<PositionInfo[]>;
 interface PositionInfo {
     liquidationPrice: number;
@@ -47,15 +127,61 @@ interface PositionInfo {
     closeFee: number;
     pnlAfterFee: number;
 }
-export declare function getPositionCount(config: TypusConfig, input: {
-    baseToken: TOKEN;
-}): Promise<number>;
-export declare function getAllPositions(config: TypusConfig, input: {
+export declare function getAllPositions(client: TypusClient, input: {
     baseToken: TOKEN;
     slice: string;
     page: string;
-}): Promise<Position[]>;
-export declare function getAllPositionsWithTradingSymbol(config: TypusConfig, input: {
+    marketIndex: string;
+}): Promise<{
+    positions: {
+        id: {
+            id: string;
+        };
+        create_ts_ms: string;
+        position_id: string;
+        linked_order_ids: string[];
+        linked_order_prices: string[];
+        user: string;
+        is_long: boolean;
+        size: string;
+        size_decimal: string;
+        collateral_token: {
+            name: string;
+        };
+        collateral_token_decimal: string;
+        symbol: {
+            base_token: {
+                name: string;
+            };
+            quote_token: {
+                name: string;
+            };
+        };
+        collateral_amount: string;
+        reserve_amount: string;
+        average_price: string;
+        entry_borrow_index: string;
+        entry_funding_rate_index_sign: boolean;
+        entry_funding_rate_index: string;
+        unrealized_loss: string;
+        unrealized_funding_sign: boolean;
+        unrealized_funding_fee: string;
+        unrealized_trading_fee: string;
+        unrealized_borrow_fee: string;
+        unrealized_rebate: string;
+        option_collateral_info: {
+            index: string;
+            bid_token: {
+                name: string;
+            };
+            bid_receipts_bcs: number[][];
+        } | null;
+        u64_padding: string[];
+    }[];
+    maxPage: number;
+}>;
+export declare function getAllPositionsWithTradingSymbol(client: TypusClient, input: {
     baseToken: TOKEN;
-}): Promise<Position[]>;
+    marketIndex: string;
+}): Promise<(typeof Position.$inferType)[]>;
 export {};