aftermath-ts-sdk/dist/packages/perpetuals/perpetualsTypes.d.ts

Aftermath TypeScript SDK

import { BcsType } from "@mysten/sui/bcs";
import { AnyObjectType, ApiDataWithCursorBody, Balance, Event, IFixed, Object, ObjectDigest, ObjectId, ObjectVersion, PackageId, Percentage, SuiAddress, Timestamp, TransactionDigest } from "../../general/types/generalTypes";
import { CoinDecimal, CoinSymbol, CoinType } from "../coin/coinTypes";
export type PerpetualsMarketId = ObjectId;
export type PerpetualsAccountId = bigint;
export type PerpetualsOrderId = bigint;
export type PerpetualsOrderIdAsString = string;
export type PerpetualsOrderPrice = bigint;
export declare enum PerpetualsOrderSide {
    Ask = 1,// true
    Bid = 0
}
export declare enum PerpetualsOrderType {
    Standard = 0,
    FillOrKill = 1,
    PostOnly = 2,
    ImmediateOrCancel = 3
}
declare function Field<N extends BcsType<any>, V extends BcsType<any>>(name: N, value: V): BcsType<{
    name: N extends BcsType<infer U, any> ? U : never;
    value: V extends BcsType<infer U, any> ? U : never;
}, {
    name: N extends BcsType<any, infer U_1> ? U_1 : never;
    value: V extends BcsType<any, infer U_1> ? U_1 : never;
}>;
export interface PerpetualsAdminCapability extends Object {
}
export interface PerpetualsRegistry extends Object {
    activeCollaterals: CoinType[];
}
export interface PerpetualsVault extends Object {
    balance: Balance;
    scalingFactor: bigint;
}
export interface PerpetualsMarketData {
    packageId: PackageId;
    objectId: ObjectId;
    initialSharedVersion: ObjectVersion;
    collateralCoinType: CoinType;
    marketParams: PerpetualsMarketParams;
    marketState: PerpetualsMarketState;
}
export interface PerpetualsAccountCap extends Object {
    accountId: PerpetualsAccountId;
    collateralCoinType: CoinType;
    collateral: IFixed;
    collateralDecimals: CoinDecimal;
    objectVersion: ObjectVersion;
    objectDigest: ObjectDigest;
}
export type PerpetualsRawAccountCap = Omit<PerpetualsAccountCap, "collateral" | "collateralDecimals"> & {
    collateral: Balance;
};
export interface PerpetualsPosition {
    collateral: IFixed;
    baseAssetAmount: IFixed;
    quoteAssetNotionalAmount: IFixed;
    cumFundingRateLong: IFixed;
    cumFundingRateShort: IFixed;
    asksQuantity: IFixed;
    bidsQuantity: IFixed;
    collateralCoinType: CoinType;
    marketId: PerpetualsMarketId;
    pendingOrders: {
        orderId: PerpetualsOrderId;
        side: PerpetualsOrderSide;
        size: bigint;
    }[];
    makerFee: IFixed;
    takerFee: IFixed;
    leverage: number;
}
export interface PerpetualsMarketParams {
    marginRatioInitial: IFixed;
    marginRatioMaintenance: IFixed;
    baseAssetSymbol: CoinSymbol;
    basePriceFeedId: ObjectId;
    collateralPriceFeedId: ObjectId;
    fundingFrequencyMs: bigint;
    fundingPeriodMs: bigint;
    premiumTwapFrequencyMs: bigint;
    premiumTwapPeriodMs: bigint;
    spreadTwapFrequencyMs: bigint;
    spreadTwapPeriodMs: bigint;
    makerFee: IFixed;
    takerFee: IFixed;
    liquidationFee: IFixed;
    forceCancelFee: IFixed;
    insuranceFundFee: IFixed;
    minOrderUsdValue: IFixed;
    lotSize: bigint;
    tickSize: bigint;
    liquidationTolerance: bigint;
    maxPendingOrders: bigint;
    oracleTolerance: bigint;
}
export interface PerpetualsMarketState {
    cumFundingRateLong: IFixed;
    cumFundingRateShort: IFixed;
    fundingLastUpdateMs: Timestamp;
    premiumTwap: IFixed;
    premiumTwapLastUpdateMs: Timestamp;
    spreadTwap: IFixed;
    spreadTwapLastUpdateMs: Timestamp;
    openInterest: IFixed;
    feesAccrued: IFixed;
}
export interface PerpetualsMarketCandleDataPoint {
    time: Timestamp;
    high: number;
    low: number;
    open: number;
    close: number;
    volume: number;
}
export interface PerpetualsOrderbook {
    bids: Record<PerpetualsOrderIdAsString, {
        accountId: PerpetualsAccountId;
        size: number;
        price: number;
    }>;
    asks: Record<PerpetualsOrderIdAsString, {
        accountId: PerpetualsAccountId;
        size: number;
        price: number;
    }>;
    asksTotalSize: number;
    bidsTotalSize: number;
    bestBidPrice: number | undefined;
    bestAskPrice: number | undefined;
    midPrice: number | undefined;
}
export interface PerpetualsOrderData {
    orderId: PerpetualsOrderId;
    initialSize: bigint;
    filledSize: bigint;
    side: PerpetualsOrderSide;
    marketId: PerpetualsMarketId;
}
export interface PerpetualsFilledOrderData {
    size: number;
    price: number;
}
export interface PerpetualsOrderInfo {
    price: PerpetualsOrderPrice;
    size: bigint;
}
export interface PerpetualsAccountData {
    accountCap: PerpetualsAccountCap;
    account: PerpetualsAccountObject;
}
export interface PerpetualsAccountObject {
    positions: PerpetualsPosition[];
}
export interface UpdatedMarketVersionEvent extends Event {
    marketId: PerpetualsMarketId;
    version: bigint;
}
export declare const isUpdatedMarketVersion: (event: Event) => event is UpdatedMarketVersionEvent;
export interface PerpetualsAccountCollateralChangesWithCursor {
    collateralChanges: PerpetualsAccountCollateralChange[];
    nextCursor: Timestamp | undefined;
}
export type PerpetualsAccountCollateralChange = {
    timestamp: Timestamp;
    txDigest: TransactionDigest;
    marketId: PerpetualsMarketId | undefined;
    eventType: AnyObjectType;
    collateralChange: number;
    collateralChangeUsd: number;
};
export interface PerpetualsAccountTradesWithCursor {
    trades: PerpetualsAccountTrade[];
    nextCursor: Timestamp | undefined;
}
export type PerpetualsAccountTrade = {
    timestamp: Timestamp;
    txDigest: TransactionDigest;
    marketId: PerpetualsMarketId;
    eventType: AnyObjectType;
    side: PerpetualsOrderSide;
} & ({
    orderPrice: bigint;
} | {
    price: number;
}) & ({
    sizeLots: bigint;
} | {
    size: number;
});
export interface DepositedCollateralEvent extends Event {
    accountId: PerpetualsAccountId;
    collateralDelta: Balance;
}
export interface AllocatedCollateralEvent extends Event {
    accountId: PerpetualsAccountId;
    collateralDelta: Balance;
    positionCollateralAfter: IFixed;
}
export interface DeallocatedCollateralEvent extends Event {
    accountId: PerpetualsAccountId;
    collateralDelta: Balance;
    positionCollateralAfter: IFixed;
}
export interface WithdrewCollateralEvent extends Event {
    accountId: PerpetualsAccountId;
    collateralDelta: Balance;
}
export interface SettledFundingEvent extends Event {
    accountId: PerpetualsAccountId;
    collateralDeltaUsd: IFixed;
    marketId: PerpetualsMarketId;
    marketFundingRateLong: IFixed;
    marketFundingRateShort: IFixed;
}
export type CollateralEvent = WithdrewCollateralEvent | DepositedCollateralEvent | SettledFundingEvent | LiquidatedEvent | FilledTakerOrderEvent | FilledMakerOrderEvent | AllocatedCollateralEvent | DeallocatedCollateralEvent;
export declare const isWithdrewCollateralEvent: (event: Event) => event is WithdrewCollateralEvent;
export declare const isDepositedCollateralEvent: (event: Event) => event is DepositedCollateralEvent;
export declare const isDeallocatedCollateralEvent: (event: Event) => event is DeallocatedCollateralEvent;
export declare const isAllocatedCollateralEvent: (event: Event) => event is AllocatedCollateralEvent;
export declare const isSettledFundingEvent: (event: Event) => event is SettledFundingEvent;
export interface LiquidatedEvent extends Event {
    accountId: PerpetualsAccountId;
    collateralDeltaUsd: IFixed;
    liqorAccountId: PerpetualsAccountId;
    size: bigint;
    markPrice: IFixed;
    marketId: PerpetualsMarketId;
    side: PerpetualsOrderSide;
}
export declare const isLiquidatedEvent: (event: Event) => event is LiquidatedEvent;
export interface CreatedAccountEvent extends Event {
    user: SuiAddress;
    accountId: PerpetualsAccountId;
}
export interface PerpetualsTradeHistoryData {
    timestamp: Timestamp;
    txDigest: TransactionDigest;
    side: PerpetualsOrderSide;
    sizeFilled: number;
    orderPrice: number;
}
export interface PerpetualsTradeHistoryWithCursor {
    trades: PerpetualsTradeHistoryData[];
    nextCursor: Timestamp | undefined;
}
export interface OrderbookPostReceiptEvent extends Event {
    accountId: PerpetualsAccountId;
    orderId: PerpetualsOrderId;
    size: bigint;
}
export interface OrderbookFillReceiptEvent extends Event {
    accountId: PerpetualsAccountId;
    orderId: PerpetualsOrderId;
    size: bigint;
    dropped: boolean;
}
export interface CanceledOrderEvent extends Event {
    accountId: PerpetualsAccountId;
    marketId: PerpetualsMarketId;
    side: PerpetualsOrderSide;
    size: bigint;
    orderId: PerpetualsOrderId;
}
export interface PostedOrderEvent extends Event {
    accountId: PerpetualsAccountId;
    marketId: PerpetualsMarketId;
    side: PerpetualsOrderSide;
    size: bigint;
    asksQuantity: IFixed;
    bidsQuantity: IFixed;
}
export interface FilledMakerOrderEvent extends Event {
    accountId: PerpetualsAccountId;
    collateralDeltaUsd: IFixed;
    marketId: PerpetualsMarketId;
    side: PerpetualsOrderSide;
    size: bigint;
    orderId: PerpetualsOrderId;
    dropped: boolean;
    baseAssetAmount: IFixed;
    quoteAssetNotionalAmount: IFixed;
    asksQuantity: IFixed;
    bidsQuantity: IFixed;
}
export interface FilledTakerOrderEvent extends Event {
    accountId: PerpetualsAccountId;
    collateralDeltaUsd: IFixed;
    marketId: PerpetualsMarketId;
    baseAssetAmount: IFixed;
    quoteAssetNotionalAmount: IFixed;
    side: PerpetualsOrderSide;
    baseAssetDelta: IFixed;
    quoteAssetDelta: IFixed;
    liquidatedVolume: IFixed;
}
export type PerpetualsOrderEvent = CanceledOrderEvent | PostedOrderReceiptEvent | FilledMakerOrderEvent | FilledTakerOrderEvent | LiquidatedEvent | ReducedOrderEvent;
export interface PostedOrderReceiptEvent extends Event {
    accountId: PerpetualsAccountId;
    marketId: PerpetualsMarketId;
    orderId: PerpetualsOrderId;
    size: bigint;
    side: PerpetualsOrderSide;
}
export interface ReducedOrderEvent extends Event {
    marketId: PerpetualsMarketId;
    accountId: PerpetualsAccountId;
    sizeChange: bigint;
    orderId: PerpetualsOrderId;
}
export declare const isCanceledOrderEvent: (event: Event) => event is CanceledOrderEvent;
export declare const isPostedOrderEvent: (event: Event) => event is PostedOrderEvent;
export declare const isPostedOrderReceiptEvent: (event: Event) => event is PostedOrderReceiptEvent;
export declare const isFilledMakerOrderEvent: (event: Event) => event is FilledMakerOrderEvent;
export declare const isFilledTakerOrderEvent: (event: Event) => event is FilledTakerOrderEvent;
export declare const isReducedOrderEvent: (event: Event) => event is ReducedOrderEvent;
export interface UpdatedPremiumTwapEvent extends Event {
    marketId: PerpetualsMarketId;
    bookPrice: IFixed;
    indexPrice: IFixed;
    premiumTwap: IFixed;
    premiumTwapLastUpdateMs: number;
}
export interface UpdatedSpreadTwapEvent extends Event {
    marketId: PerpetualsMarketId;
    bookPrice: IFixed;
    indexPrice: IFixed;
    spreadTwap: IFixed;
    spreadTwapLastUpdateMs: number;
}
export type PerpetualsTwapEvent = UpdatedPremiumTwapEvent | UpdatedSpreadTwapEvent;
export declare const isUpdatedPremiumTwapEvent: (event: Event) => event is UpdatedPremiumTwapEvent;
export declare const isUpdatedSpreadTwapEvent: (event: Event) => event is UpdatedSpreadTwapEvent;
export interface UpdatedFundingEvent extends Event {
    marketId: PerpetualsMarketId;
    cumFundingRateLong: IFixed;
    cumFundingRateShort: IFixed;
    fundingLastUpdateMs: Timestamp;
}
export declare const isUpdatedFundingEvent: (event: Event) => event is UpdatedFundingEvent;
export interface ApiPerpetualsAccountsBody {
    walletAddress: SuiAddress;
}
export type ApiPerpetualsAccountOrderHistoryBody = ApiDataWithCursorBody<Timestamp>;
export type ApiPerpetualsAccountCollateralHistoryBody = ApiDataWithCursorBody<Timestamp>;
export interface ApiPerpetualsSetPositionLeverageBody {
    walletAddress: SuiAddress;
    bytes: string;
    signature: string;
}
export type ApiPerpetualsPreviewOrderBody = (Omit<ApiPerpetualsLimitOrderBody, "collateralChange" | "walletAddress" | "accountObjectId" | "accountObjectVersion" | "accountObjectDigest"> | Omit<ApiPerpetualsMarketOrderBody, "collateralChange" | "walletAddress" | "accountObjectId" | "accountObjectVersion" | "accountObjectDigest"> | Omit<ApiPerpetualsSLTPOrderBody, "collateralChange" | "walletAddress" | "accountObjectId" | "accountObjectVersion" | "accountObjectDigest">) & {
    collateralCoinType: CoinType;
    accountId: PerpetualsAccountId;
    lotSize: number;
    tickSize: number;
    leverage: number;
};
export interface ApiPerpetualsPreviewCancelOrdersBody {
    accountId: PerpetualsAccountId;
    collateralCoinType: CoinType;
    marketIdsToData: Record<PerpetualsMarketId, {
        orderIds: PerpetualsOrderId[];
        leverage: number;
    }>;
}
export interface ApiPerpetualsPreviewReduceOrdersBody {
    marketId: PerpetualsMarketId;
    accountId: PerpetualsAccountId;
    leverage: number;
    orderIds: PerpetualsOrderId[];
    sizesToSubtract: bigint[];
    collateralCoinType: CoinType;
}
export type ApiPerpetualsPreviewReduceOrdersResponse = {
    error: string;
} | {
    positionAfterReduceOrders: PerpetualsPosition;
    collateralChange: number;
};
export type ApiPerpetualsPreviewOrderResponse = {
    error: string;
} | {
    positionAfterOrder: PerpetualsPosition;
    priceSlippage: number;
    percentSlippage: Percentage;
    filledSize: number;
    filledSizeUsd: number;
    postedSize: number;
    postedSizeUsd: number;
    collateralChange: number;
    executionPrice: number;
};
export type ApiPerpetualsPreviewCancelOrdersResponse = {
    error: string;
} | {
    marketIdsToPositionAfterCancelOrders: Record<PerpetualsMarketId, PerpetualsPosition>;
    collateralChange: number;
};
export interface ApiPerpetualsExecutionPriceBody {
    side: PerpetualsOrderSide;
    size: bigint;
    lotSize: number;
    collateral: Balance;
    basePriceFeedId: ObjectId;
    collateralPriceFeedId: ObjectId;
    price?: PerpetualsOrderPrice;
}
export interface ApiPerpetualsExecutionPriceResponse {
    executionPrice: number;
    sizeFilled: number;
    sizePosted: number;
    fills: PerpetualsFilledOrderData[];
}
export type ApiPerpetualsHistoricalMarketDataResponse = PerpetualsMarketCandleDataPoint[];
export interface ApiPerpetualsMaxOrderSizeBody {
    accountId: PerpetualsAccountId;
    collateral: Balance;
    side: PerpetualsOrderSide;
    leverage: number;
    price?: PerpetualsOrderPrice;
}
export interface ApiPerpetualsAccountOrderDatasBody {
    orderDatas: {
        orderId: PerpetualsOrderId;
        currentSize: bigint;
    }[];
}
export interface ApiPerpetualsCreateAccountBody {
    walletAddress: SuiAddress;
    collateralCoinType: CoinType;
}
export interface ApiPerpetualsDepositCollateralBody {
    walletAddress: SuiAddress;
    collateralCoinType: CoinType;
    accountCapId: ObjectId;
    amount: Balance;
    isSponsoredTx?: boolean;
}
export interface ApiPerpetualsWithdrawCollateralBody {
    walletAddress: SuiAddress;
    collateralCoinType: CoinType;
    accountCapId: ObjectId;
    amount: Balance;
}
export interface ApiPerpetualsTransferCollateralBody {
    walletAddress: SuiAddress;
    collateralCoinType: CoinType;
    fromAccountCapId: ObjectId;
    toAccountCapId: ObjectId;
    amount: Balance;
}
export interface ApiPerpetualsAllocateCollateralBody {
    walletAddress: SuiAddress;
    packageId: PackageId;
    collateralCoinType: CoinType;
    accountCapId: ObjectId;
    marketId: PerpetualsMarketId;
    marketInitialSharedVersion: ObjectVersion;
    amount: Balance;
}
export interface ApiPerpetualsDeallocateCollateralBody {
    walletAddress: SuiAddress;
    packageId: PackageId;
    collateralCoinType: CoinType;
    accountCapId: ObjectId;
    basePriceFeedId: ObjectId;
    collateralPriceFeedId: ObjectId;
    marketId: PerpetualsMarketId;
    marketInitialSharedVersion: ObjectVersion;
    amount: Balance;
}
export interface ApiPerpetualsMarketOrderBody {
    walletAddress: SuiAddress;
    marketId: PerpetualsMarketId;
    accountObjectId: ObjectId;
    accountObjectVersion: number;
    accountObjectDigest: ObjectId;
    side: PerpetualsOrderSide;
    size: bigint;
    collateralChange: Balance;
    hasPosition: boolean;
}
export interface ApiPerpetualsLimitOrderBody {
    walletAddress: SuiAddress;
    marketId: PerpetualsMarketId;
    accountObjectId: ObjectId;
    accountObjectVersion: number;
    accountObjectDigest: ObjectId;
    side: PerpetualsOrderSide;
    size: bigint;
    price: PerpetualsOrderPrice;
    orderType: PerpetualsOrderType;
    collateralChange: Balance;
    hasPosition: boolean;
}
export interface ApiPerpetualsCancelOrderBody {
    packageId: PackageId;
    walletAddress: SuiAddress;
    collateralCoinType: CoinType;
    accountCapId: ObjectId;
    marketId: PerpetualsMarketId;
    marketInitialSharedVersion: ObjectVersion;
    orderId: PerpetualsOrderId;
    collateralChange: Balance;
    basePriceFeedId: ObjectId;
    collateralPriceFeedId: ObjectId;
}
export interface ApiPerpetualsCancelOrdersBody {
    walletAddress: SuiAddress;
    collateralCoinType: CoinType;
    accountCapId: ObjectId;
    orderDatas: {
        packageId: PackageId;
        orderId: PerpetualsOrderId;
        marketId: PerpetualsMarketId;
        marketInitialSharedVersion: ObjectVersion;
        collateralChange: Balance;
        basePriceFeedId: ObjectId;
        collateralPriceFeedId: ObjectId;
    }[];
}
export interface ApiPerpetualsReduceOrdersBody {
    walletAddress: SuiAddress;
    packageId: PackageId;
    collateralCoinType: CoinType;
    accountCapId: ObjectId;
    marketId: PerpetualsMarketId;
    marketInitialSharedVersion: ObjectVersion;
    orderIds: PerpetualsOrderId[];
    sizesToSubtract: bigint[];
    basePriceFeedId: ObjectId;
    collateralPriceFeedId: ObjectId;
    collateralChange: Balance;
}
export type ApiPerpetualsSLTPOrderBody = ((ApiPerpetualsMarketOrderBody & {
    marketPrice: PerpetualsOrderPrice;
}) | ApiPerpetualsLimitOrderBody) & ({
    slPrice: PerpetualsOrderPrice;
} | {
    tpPrice: PerpetualsOrderPrice;
} | {
    slPrice: PerpetualsOrderPrice;
    tpPrice: PerpetualsOrderPrice;
});
export interface ApiPerpetualsMarket24hrVolumeResponse {
    volumeBaseAssetAmount: number;
    volumeUsd: number;
}
export interface ApiPerpetualsMarket24hrVolumeResponse {
    volumeUsd: number;
    volumeBaseAssetAmount: number;
}
export type SdkPerpetualsMarketOrderInputs = Omit<ApiPerpetualsMarketOrderBody, "accountObjectId" | "accountObjectVersion" | "accountObjectDigest">;
export type SdkPerpetualsLimitOrderInputs = Omit<ApiPerpetualsLimitOrderBody, "accountObjectId" | "accountObjectVersion" | "accountObjectDigest">;
export type SdkPerpetualsSLTPOrderInputs = ((SdkPerpetualsMarketOrderInputs & {
    marketPrice: PerpetualsOrderPrice;
}) | SdkPerpetualsLimitOrderInputs) & ({
    slPrice: PerpetualsOrderPrice;
} | {
    tpPrice: PerpetualsOrderPrice;
} | {
    slPrice: PerpetualsOrderPrice;
    tpPrice: PerpetualsOrderPrice;
});
export declare const perpetualsRegistry: {
    Account: BcsType<{
        id: string;
        accountId: string;
        collateral: {
            value: string;
        };
    }, {
        id: string | Uint8Array<ArrayBufferLike>;
        accountId: string | number | bigint;
        collateral: {
            value: string | number | bigint;
        };
    }>;
    AdminCapability: BcsType<{
        id: string;
    }, {
        id: string | Uint8Array<ArrayBufferLike>;
    }>;
    BalanceStruct: BcsType<{
        value: string;
    }, {
        value: string | number | bigint;
    }>;
    Coin: BcsType<{
        id: string;
        balance: {
            value: string;
        };
    }, {
        id: string | Uint8Array<ArrayBufferLike>;
        balance: {
            value: string | number | bigint;
        };
    }>;
    Field: typeof Field;
    MarketKey: BcsType<{
        marketId: string;
    }, {
        marketId: string | number | bigint;
    }>;
    OrderInfo: BcsType<{
        price: string;
        size: string;
    }, {
        price: string | number | bigint;
        size: string | number | bigint;
    }>;
    Position: BcsType<{
        collateral: string;
        baseAssetAmount: string;
        quoteAssetNotionalAmount: string;
        cumFundingRateLong: string;
        cumFundingRateShort: string;
        asksQuantity: string;
        bidsQuantity: string;
        pendingOrders: string;
        makerFee: string;
        takerFee: string;
    }, {
        collateral: string | number | bigint;
        baseAssetAmount: string | number | bigint;
        quoteAssetNotionalAmount: string | number | bigint;
        cumFundingRateLong: string | number | bigint;
        cumFundingRateShort: string | number | bigint;
        asksQuantity: string | number | bigint;
        bidsQuantity: string | number | bigint;
        pendingOrders: string | number | bigint;
        makerFee: string | number | bigint;
        takerFee: string | number | bigint;
    }>;
    PositionKey: BcsType<{
        accountId: string;
    }, {
        accountId: string | number | bigint;
    }>;
    Registry: BcsType<{
        id: string;
        activeCollaterals: string[];
        nextAccountId: string;
    }, {
        id: string | Uint8Array<ArrayBufferLike>;
        activeCollaterals: Iterable<string> & {
            length: number;
        };
        nextAccountId: string | number | bigint;
    }>;
    Vault: BcsType<{
        id: string;
        collateral_balance: {
            value: string;
        };
        insurance_fund_balance: {
            value: string;
        };
        scalingFactor: string;
    }, {
        id: string | Uint8Array<ArrayBufferLike>;
        collateral_balance: {
            value: string | number | bigint;
        };
        insurance_fund_balance: {
            value: string | number | bigint;
        };
        scalingFactor: string | number | bigint;
    }>;
};
export {};
//# sourceMappingURL=perpetualsTypes.d.ts.map