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

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

@@ -1,36 +0,0 @@
-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

@@ -1,151 +0,0 @@
-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

@@ -1,221 +0,0 @@
-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

@@ -1,176 +0,0 @@
-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;
-}