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

package/src/typus-perp/treasury-caps/functions.ts

@@ -0,0 +1,36 @@
+import { PUBLISHED_AT } from "..";
+import { ObjectArg, obj } from "../../_framework/util";
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+
+export function init(txb: TransactionBlock) {
+    return txb.moveCall({ target: `${PUBLISHED_AT}::treasury_caps::init`, arguments: [] });
+}
+
+export function getMutTreasuryCap(txb: TransactionBlock, typeArg: string, treasuryCaps: ObjectArg) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::treasury_caps::get_mut_treasury_cap`,
+        typeArguments: [typeArg],
+        arguments: [obj(txb, treasuryCaps)],
+    });
+}
+
+export function removeTreasuryCap(txb: TransactionBlock, typeArg: string, treasuryCaps: ObjectArg) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::treasury_caps::remove_treasury_cap`,
+        typeArguments: [typeArg],
+        arguments: [obj(txb, treasuryCaps)],
+    });
+}
+
+export interface StoreTreasuryCapArgs {
+    treasuryCaps: ObjectArg;
+    treasuryCap: ObjectArg;
+}
+
+export function storeTreasuryCap(txb: TransactionBlock, typeArg: string, args: StoreTreasuryCapArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::treasury_caps::store_treasury_cap`,
+        typeArguments: [typeArg],
+        arguments: [obj(txb, args.treasuryCaps), obj(txb, args.treasuryCap)],
+    });
+}

package/src/typus-perp/treasury-caps/structs.ts

@@ -0,0 +1,151 @@
+import { UID } from "../../_dependencies/source/0x2/object/structs";
+import {
+    PhantomReified,
+    Reified,
+    StructClass,
+    ToField,
+    ToTypeStr,
+    decodeFromFields,
+    decodeFromFieldsWithTypes,
+    decodeFromJSONField,
+    phantom,
+} from "../../_framework/reified";
+import { FieldsWithTypes, composeSuiType, compressSuiType } from "../../_framework/util";
+import { bcs, fromB64 } from "@mysten/bcs";
+import { SuiClient, SuiParsedData } from "@mysten/sui.js/client";
+
+/* ============================== TreasuryCaps =============================== */
+
+export function isTreasuryCaps(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::treasury_caps::TreasuryCaps";
+}
+
+export interface TreasuryCapsFields {
+    id: ToField<UID>;
+}
+
+export type TreasuryCapsReified = Reified<TreasuryCaps, TreasuryCapsFields>;
+
+export class TreasuryCaps implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::treasury_caps::TreasuryCaps";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = TreasuryCaps.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::treasury_caps::TreasuryCaps";
+
+    readonly $typeArgs: [];
+
+    readonly id: ToField<UID>;
+
+    private constructor(typeArgs: [], fields: TreasuryCapsFields) {
+        this.$fullTypeName = composeSuiType(
+            TreasuryCaps.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::treasury_caps::TreasuryCaps";
+        this.$typeArgs = typeArgs;
+
+        this.id = fields.id;
+    }
+
+    static reified(): TreasuryCapsReified {
+        return {
+            typeName: TreasuryCaps.$typeName,
+            fullTypeName: composeSuiType(
+                TreasuryCaps.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::treasury_caps::TreasuryCaps",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => TreasuryCaps.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => TreasuryCaps.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => TreasuryCaps.fromBcs(data),
+            bcs: TreasuryCaps.bcs,
+            fromJSONField: (field: any) => TreasuryCaps.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => TreasuryCaps.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => TreasuryCaps.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => TreasuryCaps.fetch(client, id),
+            new: (fields: TreasuryCapsFields) => {
+                return new TreasuryCaps([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return TreasuryCaps.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<TreasuryCaps>> {
+        return phantom(TreasuryCaps.reified());
+    }
+    static get p() {
+        return TreasuryCaps.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("TreasuryCaps", {
+            id: UID.bcs,
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): TreasuryCaps {
+        return TreasuryCaps.reified().new({ id: decodeFromFields(UID.reified(), fields.id) });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): TreasuryCaps {
+        if (!isTreasuryCaps(item.type)) {
+            throw new Error("not a TreasuryCaps type");
+        }
+
+        return TreasuryCaps.reified().new({ id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id) });
+    }
+
+    static fromBcs(data: Uint8Array): TreasuryCaps {
+        return TreasuryCaps.fromFields(TreasuryCaps.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            id: this.id,
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): TreasuryCaps {
+        return TreasuryCaps.reified().new({ id: decodeFromJSONField(UID.reified(), field.id) });
+    }
+
+    static fromJSON(json: Record<string, any>): TreasuryCaps {
+        if (json.$typeName !== TreasuryCaps.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return TreasuryCaps.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): TreasuryCaps {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isTreasuryCaps(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a TreasuryCaps object`);
+        }
+        return TreasuryCaps.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<TreasuryCaps> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching TreasuryCaps object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isTreasuryCaps(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a TreasuryCaps object`);
+        }
+        return TreasuryCaps.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}

package/src/typus-perp/user/order.ts

@@ -0,0 +1,221 @@
+import { SuiClient } from "@mysten/sui.js/client";
+import {
+    createTradingOrder as _createTradingOrder,
+    cancelTradingOrder as _cancelTradingOrder,
+    increaseCollateral as _increaseCollateral,
+    releaseCollateral as _releaseCollateral,
+} from "../trading/functions";
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+import { CLOCK } from "src/constants";
+import { PythClient, createPythClient, updatePyth } from "src/utils/pyth/pythClient";
+import { priceInfoObjectIds, pythStateId } from "src/utils/pyth/constant";
+import { tokenType, TOKEN, typeArgToToken } from "src/constants/token";
+import { NETWORK } from "..";
+import { Position, TradingOrder } from "../position/structs";
+
+export async function createTradingOrder(
+    config: {
+        REGISTRY: {
+            MARKET_REGISTRY: string;
+            USER: string;
+            LEADERBOARD: string;
+            LP_POOL_REGISTRY: string;
+        };
+        OBJECT: {
+            TYPUS_VERSION: string;
+            TYPUS_PERP_VERSION: string;
+        };
+    },
+    input: {
+        pythClient: PythClient;
+        tx: TransactionBlock;
+        coins: string[];
+        cToken: TOKEN;
+        amount: string;
+        tradingToken: TOKEN;
+        size: string;
+        triggerPrice: string;
+        isLong: boolean;
+        isStopOrder: boolean;
+        reduceOnly: boolean;
+        linkedPositionId: string | null;
+    }
+): Promise<TransactionBlock> {
+    // INPUTS
+    const TOKEN = input.cToken;
+    const BASE_TOKEN = input.tradingToken;
+
+    await updatePyth(input.pythClient, input.tx, [TOKEN, BASE_TOKEN]);
+    const cToken = tokenType[NETWORK][TOKEN];
+    const baseToken = tokenType[NETWORK][BASE_TOKEN];
+
+    var coin;
+
+    if (TOKEN == "SUI") {
+        [coin] = input.tx.splitCoins(input.tx.gas, [input.amount]);
+    } else {
+        const destination = input.coins.pop()!;
+
+        if (input.coins.length > 0) {
+            input.tx.mergeCoins(destination, input.coins);
+        }
+
+        [coin] = input.tx.splitCoins(destination, [input.amount]);
+    }
+
+    _createTradingOrder(input.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,
+        typusEcosystemVersion: config.OBJECT.TYPUS_VERSION,
+        typusUserRegistry: config.REGISTRY.USER,
+        typusLeaderboardRegistry: config.REGISTRY.LEADERBOARD,
+        collateral: coin,
+        size: BigInt(input.size),
+        triggerPrice: BigInt(input.triggerPrice),
+        isLong: input.isLong,
+        isStopOrder: input.isStopOrder,
+        reduceOnly: input.reduceOnly,
+        linkedPositionId: input.linkedPositionId ? BigInt(input.linkedPositionId) : null,
+    });
+
+    return input.tx;
+}
+
+export async function cancelTradingOrder(
+    config: {
+        REGISTRY: {
+            MARKET_REGISTRY: string;
+        };
+        OBJECT: {
+            TYPUS_PERP_VERSION: string;
+        };
+    },
+    input: {
+        tx: TransactionBlock;
+        order: TradingOrder;
+        user: string;
+    }
+): Promise<TransactionBlock> {
+    const cToken = "0x" + input.order.collateralToken.name;
+    const BASE_TOKEN = "0x" + input.order.symbol.baseToken.name;
+
+    const coin = _cancelTradingOrder(input.tx, [cToken, BASE_TOKEN], {
+        version: config.OBJECT.TYPUS_PERP_VERSION,
+        registry: config.REGISTRY.MARKET_REGISTRY,
+        marketIndex: BigInt(0),
+        orderId: input.order.orderId,
+        triggerPrice: input.order.triggerPrice,
+    });
+
+    input.tx.transferObjects([coin], input.user);
+
+    return input.tx;
+}
+
+export async function increaseCollateral(
+    config: {
+        REGISTRY: {
+            MARKET_REGISTRY: string;
+            LP_POOL_REGISTRY: string;
+        };
+        OBJECT: {
+            TYPUS_PERP_VERSION: string;
+        };
+    },
+    input: {
+        pythClient: PythClient;
+        tx: TransactionBlock;
+        coins: string[];
+        amount: string;
+        position: Position;
+    }
+): Promise<TransactionBlock> {
+    // parse from Position
+    const TOKEN = typeArgToToken(input.position.collateralToken.name);
+    const BASE_TOKEN = typeArgToToken(input.position.symbol.baseToken.name);
+
+    await updatePyth(input.pythClient, input.tx, [TOKEN, BASE_TOKEN]);
+    const cToken = tokenType[NETWORK][TOKEN];
+    const baseToken = tokenType[NETWORK][BASE_TOKEN];
+
+    var coin;
+
+    if (TOKEN == "SUI") {
+        [coin] = input.tx.splitCoins(input.tx.gas, [input.amount]);
+    } else {
+        const destination = input.coins.pop()!;
+
+        if (input.coins.length > 0) {
+            input.tx.mergeCoins(destination, input.coins);
+        }
+
+        [coin] = input.tx.splitCoins(destination, [input.amount]);
+    }
+
+    _increaseCollateral(input.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: BigInt(input.position.positionId),
+        collateral: coin,
+    });
+
+    return input.tx;
+}
+
+export async function releaseCollateral(
+    config: {
+        REGISTRY: {
+            MARKET_REGISTRY: string;
+            LP_POOL_REGISTRY: string;
+        };
+        OBJECT: {
+            TYPUS_PERP_VERSION: string;
+        };
+    },
+    input: {
+        pythClient: PythClient;
+        tx: TransactionBlock;
+        position: Position;
+        amount: string;
+    }
+): Promise<TransactionBlock> {
+    // parse from Position
+    const TOKEN = typeArgToToken(input.position.collateralToken.name);
+    const BASE_TOKEN = typeArgToToken(input.position.symbol.baseToken.name);
+
+    await updatePyth(input.pythClient, input.tx, [TOKEN, BASE_TOKEN]);
+    const cToken = tokenType[NETWORK][TOKEN];
+    const baseToken = tokenType[NETWORK][BASE_TOKEN];
+
+    const coin = _releaseCollateral(input.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: BigInt(input.position.positionId),
+        releaseAmount: BigInt(input.amount),
+    });
+
+    input.tx.transferObjects([coin], input.position.user);
+
+    return input.tx;
+}

package/src/typus-perp/user/orderWithBidReceipt.ts

@@ -0,0 +1,176 @@
+import {
+    createTradingOrder as _createTradingOrder,
+    cancelTradingOrder as _cancelTradingOrder,
+    increaseCollateral as _increaseCollateral,
+    releaseCollateral as _releaseCollateral,
+    createTradingOrderWithBidReceipt as _createTradingOrderWithBidReceipt,
+    reduceOptionCollateralPositionSize as _reduceOptionCollateralPositionSize,
+} from "../trading/functions";
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+import { CLOCK } from "src/constants";
+import { PythClient, createPythClient, updatePyth, updateOracleWithPyth } from "src/utils/pyth/pythClient";
+import { priceInfoObjectIds, pythStateId } from "src/utils/pyth/constant";
+import { tokenType, TOKEN, typeArgToToken } from "src/constants/token";
+import { NETWORK } from "..";
+import { Position, TradingOrder } from "../position/structs";
+import { getSplitBidReceiptTx } from "src/typus-dov-single-v2/entry/user-entry";
+
+export async function createTradingOrderWithBidReceipt(
+    config: {
+        PACKAGE_ORIGIN: { FRAMEWORK: string };
+        PACKAGE: {
+            DOV_SINGLE: string;
+            ORACLE: string;
+        };
+        REGISTRY: {
+            DOV_SINGLE: string;
+            MARKET_REGISTRY: string;
+            USER: string;
+            LEADERBOARD: string;
+            LP_POOL_REGISTRY: string;
+        };
+        OBJECT: {
+            TYPUS_VERSION: string;
+            TYPUS_PERP_VERSION: string;
+        };
+        ORACLE: {};
+    },
+    input: {
+        pythClient: PythClient;
+        tx: TransactionBlock;
+        cToken: TOKEN;
+        tradingToken: TOKEN;
+        isLong: boolean;
+        user: string;
+        index: string;
+        bToken: string;
+        bidReceipt: string;
+        share: string | null;
+    }
+): Promise<TransactionBlock> {
+    // INPUTS
+    const TOKEN = input.cToken;
+    const BASE_TOKEN = input.tradingToken;
+
+    await updatePyth(input.pythClient, input.tx, [TOKEN, BASE_TOKEN]);
+    const cToken = tokenType[NETWORK][TOKEN];
+    const bToken = tokenType[NETWORK][input.bToken];
+    const baseToken = tokenType[NETWORK][BASE_TOKEN];
+
+    updateOracleWithPyth(input.pythClient, input.tx, config.PACKAGE.ORACLE, config.ORACLE[BASE_TOKEN], BASE_TOKEN, "USDC");
+
+    // split bid receipt
+    var collateralBidReceipt;
+    if (input.share) {
+        collateralBidReceipt = getSplitBidReceiptTx({
+            tx: input.tx,
+            typusFrameworkOriginPackageId: config.PACKAGE_ORIGIN.FRAMEWORK,
+            typusDovSinglePackageId: config.PACKAGE.DOV_SINGLE,
+            typusDovSingleRegistry: config.REGISTRY.DOV_SINGLE,
+            index: input.index,
+            receipts: [input.bidReceipt],
+            share: input.share,
+            recipient: input.user,
+        });
+    } else {
+        collateralBidReceipt = input.bidReceipt;
+    }
+
+    _createTradingOrderWithBidReceipt(input.tx, [cToken, bToken, 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,
+        typusEcosystemVersion: config.OBJECT.TYPUS_VERSION,
+        typusUserRegistry: config.REGISTRY.USER,
+        typusLeaderboardRegistry: config.REGISTRY.LEADERBOARD,
+        isLong: input.isLong,
+        dovRegistry: config.REGISTRY.DOV_SINGLE,
+        typusOracle: config.ORACLE[BASE_TOKEN],
+        collateralBidReceipt,
+        user: input.user,
+    });
+
+    return input.tx;
+}
+
+export async function reduceOptionCollateralPositionSize(
+    config: {
+        PACKAGE_ORIGIN: { FRAMEWORK: string };
+        PACKAGE: {
+            DOV_SINGLE: string;
+            ORACLE: string;
+        };
+        REGISTRY: {
+            DOV_SINGLE: string;
+            MARKET_REGISTRY: string;
+            USER: string;
+            LEADERBOARD: string;
+            LP_POOL_REGISTRY: string;
+        };
+        OBJECT: {
+            TYPUS_VERSION: string;
+            TYPUS_PERP_VERSION: string;
+        };
+        ORACLE: {};
+    },
+    input: {
+        pythClient: PythClient;
+        tx: TransactionBlock;
+        position: Position;
+        size: string | null;
+    }
+): Promise<TransactionBlock> {
+    // const TOKEN = input.cToken;
+    // const BASE_TOKEN = input.tradingToken;
+
+    // await updatePyth(input.pythClient, input.tx, [TOKEN, BASE_TOKEN]);
+    // const cToken = tokenType[NETWORK][TOKEN];
+    // const bToken = tokenType[NETWORK][input.bToken];
+    // const baseToken = tokenType[NETWORK][BASE_TOKEN];
+
+    // updateOracleWithPyth(input.pythClient, input.tx, config.PACKAGE.ORACLE, config.ORACLE[BASE_TOKEN], BASE_TOKEN, "USDC");
+
+    // // split bid receipt
+    // var collateralBidReceipt;
+    // if (input.share) {
+    //     collateralBidReceipt = getSplitBidReceiptTx({
+    //         tx: input.tx,
+    //         typusFrameworkOriginPackageId: config.PACKAGE_ORIGIN.FRAMEWORK,
+    //         typusDovSinglePackageId: config.PACKAGE.DOV_SINGLE,
+    //         typusDovSingleRegistry: config.REGISTRY.DOV_SINGLE,
+    //         index: input.index,
+    //         receipts: [input.bidReceipt],
+    //         share: input.share,
+    //         recipient: input.user,
+    //     });
+    // } else {
+    //     collateralBidReceipt = input.bidReceipt;
+    // }
+
+    // _reduceOptionCollateralPositionSize(input.tx, [cToken, bToken, 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,
+    //     typusEcosystemVersion: config.OBJECT.TYPUS_VERSION,
+    //     typusUserRegistry: config.REGISTRY.USER,
+    //     typusLeaderboardRegistry: config.REGISTRY.LEADERBOARD,
+    //     dovRegistry: config.REGISTRY.DOV_SINGLE,
+    //     typusOracle: config.ORACLE[BASE_TOKEN],
+    //     positionId: BigInt(123),
+    //     orderSize: null,
+    // });
+
+    return input.tx;
+}