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

Aftermath TypeScript SDK

import { BcsType } from "@mysten/sui/bcs";
import { ApiDataWithCursorBody, Balance, Event, IFixed, Object, ObjectDigest, ObjectId, ObjectVersion, 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 PerpetualsOrderPrice = bigint;
export declare enum PerpetualsOrderSide {
    Ask = 1,
    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 {
    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;
    fundingLastUpdMs: Timestamp;
    premiumTwap: IFixed;
    premiumTwapLastUpdMs: Timestamp;
    spreadTwap: IFixed;
    spreadTwapLastUpdMs: Timestamp;
    openInterest: IFixed;
    feesAccrued: IFixed;
}
export interface PerpetualsMarketCandleDataPoint {
    timestamp: Timestamp;
    high: number;
    low: number;
    open: number;
    close: number;
    volume: number;
}
export interface OrderbookDataPoint {
    price: number;
    size: number;
    totalSize: number;
    sizeUsd: number;
    totalSizeUsd: number;
}
export interface PerpetualsOrderbookState {
    bids: OrderbookDataPoint[];
    asks: OrderbookDataPoint[];
    minAskPrice: number;
    maxBidPrice: number;
}
export interface PerpetualsOrderData {
    orderId: PerpetualsOrderId;
    initialSize: bigint;
    filledSize: bigint;
    side: PerpetualsOrderSide;
    marketId: PerpetualsMarketId;
}
export interface PerpetualsFilledOrderData {
    size: number;
    price: number;
}
export interface PerpetualsOrderbook extends Object {
    asks: PerpetualsOrderedMap<PerpetualsOrder>;
    bids: PerpetualsOrderedMap<PerpetualsOrder>;
    counter: bigint;
}
export interface PerpetualsOrder {
    accountId: PerpetualsAccountId;
    size: bigint;
}
export interface PerpetualsOrderInfo {
    price: PerpetualsOrderPrice;
    size: bigint;
}
export interface PerpetualsOrderedMap<T> extends Object {
    size: bigint;
    counter: bigint;
    root: bigint;
    first: bigint;
    branchMin: bigint;
    branchMax: bigint;
    leafMin: bigint;
    leafMax: bigint;
    branchesMergeMax: bigint;
    leavesMergeMax: bigint;
}
declare function PerpetualsMap<T extends BcsType<any>>(T: T): BcsType<{
    id: string;
    size: string;
    counter: string;
    root: string;
    first: string;
    branchMin: string;
    branchMax: string;
    leafMin: string;
    leafMax: string;
    branchesMergeMax: string;
    leavesMergeMax: string;
}, {
    id: string | Uint8Array;
    size: string | number | bigint;
    counter: string | number | bigint;
    root: string | number | bigint;
    first: string | number | bigint;
    branchMin: string | number | bigint;
    branchMax: string | number | bigint;
    leafMin: string | number | bigint;
    leafMax: string | number | bigint;
    branchesMergeMax: string | number | bigint;
    leavesMergeMax: string | number | bigint;
}>;
export interface PerpetualsBranch {
    keys: bigint[];
    kids: bigint[];
}
export declare const Branch: BcsType<{
    keys: string[];
    kids: string[];
}, {
    keys: Iterable<string | number | bigint> & {
        length: number;
    };
    kids: Iterable<string | number | bigint> & {
        length: number;
    };
}>;
export interface PerpetualsLeaf<V> {
    keys: bigint[];
    vals: V[];
    next: bigint;
}
export declare function Leaf<V extends BcsType<any>>(V: V): BcsType<{
    keys: string[];
    vals: any[];
    next: string;
}, {
    keys: Iterable<string | number | bigint> & {
        length: number;
    };
    vals: Iterable<any> & {
        length: number;
    };
    next: string | number | bigint;
}>;
export interface PerpetualsAccountData {
    accountCap: PerpetualsAccountCap;
    account: PerpetualsAccountObject;
}
export interface PerpetualsAccountObject {
    positions: PerpetualsPosition[];
}
export interface PerpetualsAccountCollateralChangesWithCursor {
    collateralChanges: PerpetualsAccountCollateralChange[];
    nextCursor: Timestamp | undefined;
}
export type PerpetualsCollateralEventName = "Withdraw" | "Deposit" | "Allocate" | "Deallocate" | "SettleFunding" | "Liquidated" | "FilledTaker" | "FilledMaker";
export type PerpetualsAccountCollateralChange = {
    timestamp: Timestamp;
    txDigest: TransactionDigest;
    eventName: PerpetualsCollateralEventName;
} & ({
    collateralChange: Balance;
} | {
    collateralChangeUsd: number;
});
export interface PerpetualsAccountTradesWithCursor {
    trades: PerpetualsAccountTrade[];
    nextCursor: Timestamp | undefined;
}
export type PerpetualsTradeEventName = "Canceled" | "Posted" | "FilledMaker" | "FilledTaker" | "Liquidated";
export type PerpetualsAccountTrade = {
    timestamp: Timestamp;
    txDigest: TransactionDigest;
    marketId: PerpetualsMarketId;
    eventName: PerpetualsTradeEventName;
    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;
export interface PostedOrderReceiptEvent extends Event {
    accountId: PerpetualsAccountId;
    marketId: PerpetualsMarketId;
    orderId: PerpetualsOrderId;
    size: bigint;
    side: PerpetualsOrderSide;
}
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 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 interface ApiPerpetualsAccountsBody {
    walletAddress: SuiAddress;
}
export type ApiPerpetualsAccountOrderHistoryBody = ApiDataWithCursorBody<Timestamp> & {
    accountCapId: ObjectId;
};
export type ApiPerpetualsAccountCollateralHistoryBody = ApiDataWithCursorBody<Timestamp> & {
    accountCapId: ObjectId;
};
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 type ApiPerpetualsPreviewOrderResponse = {
    error: string;
} | {
    positionAfterOrder: PerpetualsPosition;
    priceSlippage: number;
    percentSlippage: Percentage;
    filledSize: number;
    filledSizeUsd: number;
    postedSize: number;
    postedSizeUsd: number;
    collateralChange: number;
    executionPrice: number;
};
export interface ApiPerpetualsOrderbookStateBody {
    orderbookPrice: number;
    lotSize: number;
    tickSize: number;
    priceBucketSize: 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 {
    accountCapId: ObjectId;
    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 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 {
    walletAddress: SuiAddress;
    collateralCoinType: CoinType;
    accountCapId: ObjectId;
    marketId: PerpetualsMarketId;
    marketInitialSharedVersion: ObjectVersion;
    orderId: PerpetualsOrderId;
    collateral: Balance;
    basePriceFeedId: ObjectId;
    collateralPriceFeedId: ObjectId;
}
export interface ApiPerpetualsCancelOrdersBody {
    walletAddress: SuiAddress;
    collateralCoinType: CoinType;
    accountCapId: ObjectId;
    orderDatas: {
        orderId: PerpetualsOrderId;
        marketId: PerpetualsMarketId;
        marketInitialSharedVersion: ObjectVersion;
        collateral: Balance;
        basePriceFeedId: ObjectId;
        collateralPriceFeedId: ObjectId;
    }[];
}
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;
        accountId: string | number | bigint;
        collateral: {
            value: string | number | bigint;
        };
    }>;
    AdminCapability: BcsType<{
        id: string;
    }, {
        id: string | Uint8Array;
    }>;
    BalanceStruct: BcsType<{
        value: string;
    }, {
        value: string | number | bigint;
    }>;
    Branch: BcsType<{
        keys: string[];
        kids: string[];
    }, {
        keys: Iterable<string | number | bigint> & {
            length: number;
        };
        kids: Iterable<string | number | bigint> & {
            length: number;
        };
    }>;
    Coin: BcsType<{
        id: string;
        balance: {
            value: string;
        };
    }, {
        id: string | Uint8Array;
        balance: {
            value: string | number | bigint;
        };
    }>;
    Field: typeof Field;
    Leaf: typeof Leaf;
    MarketKey: BcsType<{
        marketId: string;
    }, {
        marketId: string | number | bigint;
    }>;
    Order: BcsType<{
        accountId: string;
        size: string;
    }, {
        accountId: string | number | bigint;
        size: string | number | bigint;
    }>;
    Orderbook: BcsType<{
        id: string;
        asks: {
            id: string;
            size: string;
            counter: string;
            root: string;
            first: string;
            branchMin: string;
            branchMax: string;
            leafMin: string;
            leafMax: string;
            branchesMergeMax: string;
            leavesMergeMax: string;
        };
        bids: {
            id: string;
            size: string;
            counter: string;
            root: string;
            first: string;
            branchMin: string;
            branchMax: string;
            leafMin: string;
            leafMax: string;
            branchesMergeMax: string;
            leavesMergeMax: string;
        };
        counter: string;
    }, {
        id: string | Uint8Array;
        asks: {
            id: string | Uint8Array;
            size: string | number | bigint;
            counter: string | number | bigint;
            root: string | number | bigint;
            first: string | number | bigint;
            branchMin: string | number | bigint;
            branchMax: string | number | bigint;
            leafMin: string | number | bigint;
            leafMax: string | number | bigint;
            branchesMergeMax: string | number | bigint;
            leavesMergeMax: string | number | bigint;
        };
        bids: {
            id: string | Uint8Array;
            size: string | number | bigint;
            counter: string | number | bigint;
            root: string | number | bigint;
            first: string | number | bigint;
            branchMin: string | number | bigint;
            branchMax: string | number | bigint;
            leafMin: string | number | bigint;
            leafMax: string | number | bigint;
            branchesMergeMax: string | number | bigint;
            leavesMergeMax: string | number | bigint;
        };
        counter: string | number | bigint;
    }>;
    OrderInfo: BcsType<{
        price: string;
        size: string;
    }, {
        price: string | number | bigint;
        size: string | number | bigint;
    }>;
    PerpetualsMap: typeof PerpetualsMap;
    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;
        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;
        collateral_balance: {
            value: string | number | bigint;
        };
        insurance_fund_balance: {
            value: string | number | bigint;
        };
        scalingFactor: string | number | bigint;
    }>;
};
export {};
//# sourceMappingURL=perpetualsTypes.d.ts.map