@waterx/sdk 3.0.1 → 3.1.0

package/dist/cjs/src/generated/waterx_perp/request.d.ts

@@ -0,0 +1,544 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/**
+ * Hot potato request for trading actions in WaterX Perp. No drop trait — must be
+ * consumed by trading::execute().
+ */
+import { MoveStruct, type RawTransactionArgument } from '../utils/index.ts';
+import { type BcsType } from '@mysten/sui/bcs';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+export declare const PlaceOrderArgument: MoveStruct<{
+    is_long: BcsType<boolean, boolean, "bool">;
+    is_stop_order: BcsType<boolean, boolean, "bool">;
+    reduce_only: BcsType<boolean, boolean, "bool">;
+    /** Scaled Float (1e9) — converted internally. */
+    size: BcsType<string, string | number | bigint, "u128">;
+    /** `None` = market order (parked at tick 0). Pre-orders must be `Some`. */
+    trigger_price: BcsType<string | null, string | number | bigint | null | undefined, "Option<u128>">;
+    /** `None` = standalone. Pre-orders must be `None` (auto-linked at activation). */
+    linked_position_id: BcsType<string | null, string | number | bigint | null | undefined, "Option<u64>">;
+    /** Honored only on market orders. */
+    acceptable_price: BcsType<string | null, string | number | bigint | null | undefined, "Option<u64>">;
+    /** Collateral debited from the wxa account. Pre-orders must be `0`. */
+    collateral_amount: BcsType<string, string | number | bigint, "u64">;
+}, "@waterx/perp::request::PlaceOrderArgument">;
+export declare const TradingRequest: MoveStruct<{
+    market_id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    account_object_address: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    action: BcsType<number, number, "u8">;
+    sender: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    is_long: BcsType<boolean, boolean, "bool">;
+    size: MoveStruct<{
+        value: BcsType<string, string | number | bigint, "u128">;
+    }, "bucket_v2_framework::float::Float">;
+    collateral: MoveStruct<{
+        value: BcsType<string, string | number | bigint, "u64">;
+    }, "0x2::balance::Balance<phantom T>">;
+    order_id: BcsType<string | null, string | number | bigint | null | undefined, "Option<u64>">;
+    position_id: BcsType<string | null, string | number | bigint | null | undefined, "Option<u64>">;
+    trigger_price: BcsType<{
+        value: string;
+    } | null, {
+        value: string | number | bigint;
+    } | null | undefined, "Option<bucket_v2_framework::float::Float>">;
+    reduce_only: BcsType<boolean, boolean, "bool">;
+    is_stop_order: BcsType<boolean, boolean, "bool">;
+    linked_position_id: BcsType<string | null, string | number | bigint | null | undefined, "Option<u64>">;
+    trigger_price_key: BcsType<string | null, string | number | bigint | null | undefined, "Option<u128>">;
+    withdraw_amount: BcsType<string, string | number | bigint, "u64">;
+    /**
+     * Slippage protection: acceptable execution price (0 = no limit). For long open /
+     * short close: assert price <= acceptable_price. For short open / long close:
+     * assert price >= acceptable_price.
+     */
+    acceptable_price: BcsType<string, string | number | bigint, "u64">;
+    /**
+     * TP / SL pre-orders carried alongside a place-order action. Empty for
+     * non-`ACTION_PLACE_ORDER` actions and for plain main orders.
+     */
+    pre_orders: BcsType<{
+        is_long: boolean;
+        is_stop_order: boolean;
+        reduce_only: boolean;
+        size: string;
+        trigger_price: string | null;
+        linked_position_id: string | null;
+        acceptable_price: string | null;
+        collateral_amount: string;
+    }[], Iterable<{
+        is_long: boolean;
+        is_stop_order: boolean;
+        reduce_only: boolean;
+        size: string | number | bigint;
+        trigger_price: string | number | bigint | null | undefined;
+        linked_position_id: string | number | bigint | null | undefined;
+        acceptable_price: string | number | bigint | null | undefined;
+        collateral_amount: string | number | bigint;
+    }> & {
+        length: number;
+    }, string>;
+    witnesses: MoveStruct<any, any>;
+}, "@waterx/perp::request::TradingRequest<phantom C_TOKEN>">;
+export interface NewPlaceOrderArgumentArguments {
+    isLong: RawTransactionArgument<boolean>;
+    isStopOrder: RawTransactionArgument<boolean>;
+    reduceOnly: RawTransactionArgument<boolean>;
+    size: RawTransactionArgument<number | bigint>;
+    triggerPrice: RawTransactionArgument<number | bigint | null>;
+    linkedPositionId: RawTransactionArgument<number | bigint | null>;
+    acceptablePrice: RawTransactionArgument<number | bigint | null>;
+    collateralAmount: RawTransactionArgument<number | bigint>;
+}
+export interface NewPlaceOrderArgumentOptions {
+    package?: string;
+    arguments: NewPlaceOrderArgumentArguments | [
+        isLong: RawTransactionArgument<boolean>,
+        isStopOrder: RawTransactionArgument<boolean>,
+        reduceOnly: RawTransactionArgument<boolean>,
+        size: RawTransactionArgument<number | bigint>,
+        triggerPrice: RawTransactionArgument<number | bigint | null>,
+        linkedPositionId: RawTransactionArgument<number | bigint | null>,
+        acceptablePrice: RawTransactionArgument<number | bigint | null>,
+        collateralAmount: RawTransactionArgument<number | bigint>
+    ];
+}
+export declare function newPlaceOrderArgument(options: NewPlaceOrderArgumentOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ArgIsLongArguments {
+    self: TransactionArgument;
+}
+export interface ArgIsLongOptions {
+    package?: string;
+    arguments: ArgIsLongArguments | [
+        self: TransactionArgument
+    ];
+}
+export declare function argIsLong(options: ArgIsLongOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ArgIsStopOrderArguments {
+    self: TransactionArgument;
+}
+export interface ArgIsStopOrderOptions {
+    package?: string;
+    arguments: ArgIsStopOrderArguments | [
+        self: TransactionArgument
+    ];
+}
+export declare function argIsStopOrder(options: ArgIsStopOrderOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ArgReduceOnlyArguments {
+    self: TransactionArgument;
+}
+export interface ArgReduceOnlyOptions {
+    package?: string;
+    arguments: ArgReduceOnlyArguments | [
+        self: TransactionArgument
+    ];
+}
+export declare function argReduceOnly(options: ArgReduceOnlyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ArgSizeArguments {
+    self: TransactionArgument;
+}
+export interface ArgSizeOptions {
+    package?: string;
+    arguments: ArgSizeArguments | [
+        self: TransactionArgument
+    ];
+}
+export declare function argSize(options: ArgSizeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ArgTriggerPriceArguments {
+    self: TransactionArgument;
+}
+export interface ArgTriggerPriceOptions {
+    package?: string;
+    arguments: ArgTriggerPriceArguments | [
+        self: TransactionArgument
+    ];
+}
+export declare function argTriggerPrice(options: ArgTriggerPriceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ArgLinkedPositionIdArguments {
+    self: TransactionArgument;
+}
+export interface ArgLinkedPositionIdOptions {
+    package?: string;
+    arguments: ArgLinkedPositionIdArguments | [
+        self: TransactionArgument
+    ];
+}
+export declare function argLinkedPositionId(options: ArgLinkedPositionIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ArgAcceptablePriceArguments {
+    self: TransactionArgument;
+}
+export interface ArgAcceptablePriceOptions {
+    package?: string;
+    arguments: ArgAcceptablePriceArguments | [
+        self: TransactionArgument
+    ];
+}
+export declare function argAcceptablePrice(options: ArgAcceptablePriceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ArgCollateralAmountArguments {
+    self: TransactionArgument;
+}
+export interface ArgCollateralAmountOptions {
+    package?: string;
+    arguments: ArgCollateralAmountArguments | [
+        self: TransactionArgument
+    ];
+}
+export declare function argCollateralAmount(options: ArgCollateralAmountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AddWitnessArguments<W extends BcsType<any>> {
+    self: TransactionArgument;
+    Witness: RawTransactionArgument<W>;
+}
+export interface AddWitnessOptions<W extends BcsType<any>> {
+    package?: string;
+    arguments: AddWitnessArguments<W> | [
+        self: TransactionArgument,
+        Witness: RawTransactionArgument<W>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Adds a witness type to the request. */
+export declare function addWitness<W extends BcsType<any>>(options: AddWitnessOptions<W>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MarketIdArguments {
+    self: TransactionArgument;
+}
+export interface MarketIdOptions {
+    package?: string;
+    arguments: MarketIdArguments | [
+        self: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function marketId(options: MarketIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AccountIdArguments {
+    self: TransactionArgument;
+}
+export interface AccountIdOptions {
+    package?: string;
+    arguments: AccountIdArguments | [
+        self: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function accountId(options: AccountIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AccountObjectAddressArguments {
+    self: TransactionArgument;
+}
+export interface AccountObjectAddressOptions {
+    package?: string;
+    arguments: AccountObjectAddressArguments | [
+        self: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function accountObjectAddress(options: AccountObjectAddressOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ActionArguments {
+    self: TransactionArgument;
+}
+export interface ActionOptions {
+    package?: string;
+    arguments: ActionArguments | [
+        self: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function action(options: ActionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SenderArguments {
+    self: TransactionArgument;
+}
+export interface SenderOptions {
+    package?: string;
+    arguments: SenderArguments | [
+        self: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function sender(options: SenderOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsLongArguments {
+    self: TransactionArgument;
+}
+export interface IsLongOptions {
+    package?: string;
+    arguments: IsLongArguments | [
+        self: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function isLong(options: IsLongOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SizeArguments {
+    self: TransactionArgument;
+}
+export interface SizeOptions {
+    package?: string;
+    arguments: SizeArguments | [
+        self: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function size(options: SizeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DepositAmountArguments {
+    self: TransactionArgument;
+}
+export interface DepositAmountOptions {
+    package?: string;
+    arguments: DepositAmountArguments | [
+        self: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function depositAmount(options: DepositAmountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderIdArguments {
+    self: TransactionArgument;
+}
+export interface OrderIdOptions {
+    package?: string;
+    arguments: OrderIdArguments | [
+        self: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function orderId(options: OrderIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PositionIdArguments {
+    self: TransactionArgument;
+}
+export interface PositionIdOptions {
+    package?: string;
+    arguments: PositionIdArguments | [
+        self: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function positionId(options: PositionIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TriggerPriceArguments {
+    self: TransactionArgument;
+}
+export interface TriggerPriceOptions {
+    package?: string;
+    arguments: TriggerPriceArguments | [
+        self: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function triggerPrice(options: TriggerPriceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ReduceOnlyArguments {
+    self: TransactionArgument;
+}
+export interface ReduceOnlyOptions {
+    package?: string;
+    arguments: ReduceOnlyArguments | [
+        self: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function reduceOnly(options: ReduceOnlyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsStopOrderArguments {
+    self: TransactionArgument;
+}
+export interface IsStopOrderOptions {
+    package?: string;
+    arguments: IsStopOrderArguments | [
+        self: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function isStopOrder(options: IsStopOrderOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface LinkedPositionIdArguments {
+    self: TransactionArgument;
+}
+export interface LinkedPositionIdOptions {
+    package?: string;
+    arguments: LinkedPositionIdArguments | [
+        self: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function linkedPositionId(options: LinkedPositionIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TriggerPriceKeyArguments {
+    self: TransactionArgument;
+}
+export interface TriggerPriceKeyOptions {
+    package?: string;
+    arguments: TriggerPriceKeyArguments | [
+        self: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function triggerPriceKey(options: TriggerPriceKeyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface WithdrawAmountArguments {
+    self: TransactionArgument;
+}
+export interface WithdrawAmountOptions {
+    package?: string;
+    arguments: WithdrawAmountArguments | [
+        self: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function withdrawAmount(options: WithdrawAmountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AcceptablePriceArguments {
+    self: TransactionArgument;
+}
+export interface AcceptablePriceOptions {
+    package?: string;
+    arguments: AcceptablePriceArguments | [
+        self: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function acceptablePrice(options: AcceptablePriceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PreOrdersArguments {
+    self: TransactionArgument;
+}
+export interface PreOrdersOptions {
+    package?: string;
+    arguments: PreOrdersArguments | [
+        self: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function preOrders(options: PreOrdersOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface WitnessesArguments {
+    self: TransactionArgument;
+}
+export interface WitnessesOptions {
+    package?: string;
+    arguments: WitnessesArguments | [
+        self: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function witnesses(options: WitnessesOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ActionPlaceOrderOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function actionPlaceOrder(options?: ActionPlaceOrderOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface NewArguments {
+    marketId: RawTransactionArgument<string>;
+    accountObjectAddress: RawTransactionArgument<string>;
+    action: RawTransactionArgument<number>;
+    sender: RawTransactionArgument<string>;
+    isLong: RawTransactionArgument<boolean>;
+    size: TransactionArgument;
+    collateral: TransactionArgument;
+    orderId: RawTransactionArgument<number | bigint | null>;
+    positionId: RawTransactionArgument<number | bigint | null>;
+    triggerPrice: TransactionArgument;
+    reduceOnly: RawTransactionArgument<boolean>;
+    isStopOrder: RawTransactionArgument<boolean>;
+    linkedPositionId: RawTransactionArgument<number | bigint | null>;
+    triggerPriceKey: RawTransactionArgument<number | bigint | null>;
+    withdrawAmount: RawTransactionArgument<number | bigint>;
+    acceptablePrice: RawTransactionArgument<number | bigint>;
+    preOrders: TransactionArgument;
+}
+export interface NewOptions {
+    package?: string;
+    arguments: NewArguments | [
+        marketId: RawTransactionArgument<string>,
+        accountObjectAddress: RawTransactionArgument<string>,
+        action: RawTransactionArgument<number>,
+        sender: RawTransactionArgument<string>,
+        isLong: RawTransactionArgument<boolean>,
+        size: TransactionArgument,
+        collateral: TransactionArgument,
+        orderId: RawTransactionArgument<number | bigint | null>,
+        positionId: RawTransactionArgument<number | bigint | null>,
+        triggerPrice: TransactionArgument,
+        reduceOnly: RawTransactionArgument<boolean>,
+        isStopOrder: RawTransactionArgument<boolean>,
+        linkedPositionId: RawTransactionArgument<number | bigint | null>,
+        triggerPriceKey: RawTransactionArgument<number | bigint | null>,
+        withdrawAmount: RawTransactionArgument<number | bigint>,
+        acceptablePrice: RawTransactionArgument<number | bigint>,
+        preOrders: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Creates a new TradingRequest. Package visibility only. */
+export declare function _new(options: NewOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DestroyArguments {
+    self: TransactionArgument;
+}
+export interface DestroyOptions {
+    package?: string;
+    arguments: DestroyArguments | [
+        self: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Destroys a TradingRequest, returning its fields. Package visibility only. */
+export declare function destroy(options: DestroyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface NewNoCollateralArguments {
+    marketId: RawTransactionArgument<string>;
+    accountObjectAddress: RawTransactionArgument<string>;
+    action: RawTransactionArgument<number>;
+    sender: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint | null>;
+    positionId: RawTransactionArgument<number | bigint | null>;
+    withdrawAmount: RawTransactionArgument<number | bigint>;
+    acceptablePrice: RawTransactionArgument<number | bigint>;
+}
+export interface NewNoCollateralOptions {
+    package?: string;
+    arguments: NewNoCollateralArguments | [
+        marketId: RawTransactionArgument<string>,
+        accountObjectAddress: RawTransactionArgument<string>,
+        action: RawTransactionArgument<number>,
+        sender: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint | null>,
+        positionId: RawTransactionArgument<number | bigint | null>,
+        withdrawAmount: RawTransactionArgument<number | bigint>,
+        acceptablePrice: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Creates an empty-collateral request (for actions that don't need collateral). */
+export declare function newNoCollateral(options: NewNoCollateralOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;