@waterx/sdk 3.0.1 → 3.1.0

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

@@ -0,0 +1,247 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/** Droppable response returned by WaterX Perp trading execution. */
+import { MoveStruct, type RawTransactionArgument } from '../utils/index.ts';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+export declare const TradingResponse: MoveStruct<{
+    /** Trading market object id. */
+    market_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    /** Affected wxa account id. Use this for ownership attribution. */
+    account_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    /** One of the `waterx_perp::trading::action_*` values. */
+    action: import("@mysten/sui/bcs").BcsType<number, number, "u8">;
+    /** Execution caller. This can be a keeper or risk manager. */
+    sender: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    /** Order id touched or created by the execution, when applicable. */
+    order_id: import("@mysten/sui/bcs").BcsType<string | null, string | number | bigint | null | undefined, "Option<u64>">;
+    /** Position id touched or created by the execution, when applicable. */
+    position_id: import("@mysten/sui/bcs").BcsType<string | null, string | number | bigint | null | undefined, "Option<u64>">;
+    /** Raw collateral-token PnL amount. Direction is `pnl_is_profit`. */
+    pnl_amount: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    /** Meaningful only when `pnl_amount > 0`. */
+    pnl_is_profit: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
+    /** Raw collateral-token fees recorded or realized by this execution. */
+    fee_amount: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    /** Raw collateral amount credited back to the affected wxa account. */
+    returned_collateral_amount: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    /** Raw collateral newly provided by this execution. */
+    input_collateral_amount: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    /** Post-action position collateral, or zero when no position remains. */
+    position_collateral_amount: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    /** Order or position direction for the executed action. */
+    is_long: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
+    /** Executed or requested size when surfaced by the path; zero if not applicable. */
+    size: MoveStruct<{
+        value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u128">;
+    }, "bucket_v2_framework::float::Float">;
+    /** Execution or trigger price when surfaced by the path; zero if not applicable. */
+    execution_price: MoveStruct<{
+        value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u128">;
+    }, "bucket_v2_framework::float::Float">;
+}, "@waterx/perp::response::TradingResponse">;
+export interface MarketIdArguments {
+    self: TransactionArgument;
+}
+export interface MarketIdOptions {
+    package?: string;
+    arguments: MarketIdArguments | [
+        self: TransactionArgument
+    ];
+}
+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
+    ];
+}
+export declare function accountId(options: AccountIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ActionArguments {
+    self: TransactionArgument;
+}
+export interface ActionOptions {
+    package?: string;
+    arguments: ActionArguments | [
+        self: TransactionArgument
+    ];
+}
+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
+    ];
+}
+export declare function sender(options: SenderOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderIdArguments {
+    self: TransactionArgument;
+}
+export interface OrderIdOptions {
+    package?: string;
+    arguments: OrderIdArguments | [
+        self: TransactionArgument
+    ];
+}
+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
+    ];
+}
+export declare function positionId(options: PositionIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PnlAmountArguments {
+    self: TransactionArgument;
+}
+export interface PnlAmountOptions {
+    package?: string;
+    arguments: PnlAmountArguments | [
+        self: TransactionArgument
+    ];
+}
+export declare function pnlAmount(options: PnlAmountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PnlIsProfitArguments {
+    self: TransactionArgument;
+}
+export interface PnlIsProfitOptions {
+    package?: string;
+    arguments: PnlIsProfitArguments | [
+        self: TransactionArgument
+    ];
+}
+export declare function pnlIsProfit(options: PnlIsProfitOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface FeeAmountArguments {
+    self: TransactionArgument;
+}
+export interface FeeAmountOptions {
+    package?: string;
+    arguments: FeeAmountArguments | [
+        self: TransactionArgument
+    ];
+}
+export declare function feeAmount(options: FeeAmountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ReturnedCollateralAmountArguments {
+    self: TransactionArgument;
+}
+export interface ReturnedCollateralAmountOptions {
+    package?: string;
+    arguments: ReturnedCollateralAmountArguments | [
+        self: TransactionArgument
+    ];
+}
+export declare function returnedCollateralAmount(options: ReturnedCollateralAmountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface InputCollateralAmountArguments {
+    self: TransactionArgument;
+}
+export interface InputCollateralAmountOptions {
+    package?: string;
+    arguments: InputCollateralAmountArguments | [
+        self: TransactionArgument
+    ];
+}
+/**
+ * Collateral newly provided by this execution. This is zero for close, cancel,
+ * decrease, withdraw, and liquidation paths.
+ */
+export declare function inputCollateralAmount(options: InputCollateralAmountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PositionCollateralAmountArguments {
+    self: TransactionArgument;
+}
+export interface PositionCollateralAmountOptions {
+    package?: string;
+    arguments: PositionCollateralAmountArguments | [
+        self: TransactionArgument
+    ];
+}
+/**
+ * Position collateral after this execution, when a position remains or was opened.
+ * This is zero when no position state exists after the action.
+ */
+export declare function positionCollateralAmount(options: PositionCollateralAmountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsLongArguments {
+    self: TransactionArgument;
+}
+export interface IsLongOptions {
+    package?: string;
+    arguments: IsLongArguments | [
+        self: TransactionArgument
+    ];
+}
+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
+    ];
+}
+export declare function size(options: SizeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ExecutionPriceArguments {
+    self: TransactionArgument;
+}
+export interface ExecutionPriceOptions {
+    package?: string;
+    arguments: ExecutionPriceArguments | [
+        self: TransactionArgument
+    ];
+}
+export declare function executionPrice(options: ExecutionPriceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface NewArguments {
+    marketId: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    action: RawTransactionArgument<number>;
+    sender: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint | null>;
+    positionId: RawTransactionArgument<number | bigint | null>;
+    pnlAmount: RawTransactionArgument<number | bigint>;
+    pnlIsProfit: RawTransactionArgument<boolean>;
+    feeAmount: RawTransactionArgument<number | bigint>;
+    returnedCollateralAmount: RawTransactionArgument<number | bigint>;
+    inputCollateralAmount: RawTransactionArgument<number | bigint>;
+    positionCollateralAmount: RawTransactionArgument<number | bigint>;
+    isLong: RawTransactionArgument<boolean>;
+    size: TransactionArgument;
+    executionPrice: TransactionArgument;
+}
+export interface NewOptions {
+    package?: string;
+    arguments: NewArguments | [
+        marketId: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>,
+        action: RawTransactionArgument<number>,
+        sender: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint | null>,
+        positionId: RawTransactionArgument<number | bigint | null>,
+        pnlAmount: RawTransactionArgument<number | bigint>,
+        pnlIsProfit: RawTransactionArgument<boolean>,
+        feeAmount: RawTransactionArgument<number | bigint>,
+        returnedCollateralAmount: RawTransactionArgument<number | bigint>,
+        inputCollateralAmount: RawTransactionArgument<number | bigint>,
+        positionCollateralAmount: RawTransactionArgument<number | bigint>,
+        isLong: RawTransactionArgument<boolean>,
+        size: TransactionArgument,
+        executionPrice: TransactionArgument
+    ];
+}
+/**
+ * Construct a `TradingResponse` receipt. Each dispatch arm in
+ * `waterx_perp::trading` builds exactly one receipt at the tail of the action;
+ * fields not surfaced by a given path are passed as zero / `option::none()` per
+ * the per-field doc comments on the struct. `public(package)` so only this package
+ * can mint receipts — external consumers receive them via the
+ * `vector<TradingResponse>` returns of `trading::execute` and the keeper
+ * entrypoints.
+ */
+export declare function _new(options: NewOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;

package/dist/cjs/src/generated/waterx_perp/response.js

@@ -0,0 +1,331 @@
+"use strict";
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradingResponse = void 0;
+exports.marketId = marketId;
+exports.accountId = accountId;
+exports.action = action;
+exports.sender = sender;
+exports.orderId = orderId;
+exports.positionId = positionId;
+exports.pnlAmount = pnlAmount;
+exports.pnlIsProfit = pnlIsProfit;
+exports.feeAmount = feeAmount;
+exports.returnedCollateralAmount = returnedCollateralAmount;
+exports.inputCollateralAmount = inputCollateralAmount;
+exports.positionCollateralAmount = positionCollateralAmount;
+exports.isLong = isLong;
+exports.size = size;
+exports.executionPrice = executionPrice;
+exports._new = _new;
+/** Droppable response returned by WaterX Perp trading execution. */
+const index_ts_1 = require("../utils/index.js");
+const bcs_1 = require("@mysten/sui/bcs");
+const float = __importStar(require("./deps/bucket_v2_framework/float.js"));
+const $moduleName = '@waterx/perp::response';
+exports.TradingResponse = new index_ts_1.MoveStruct({ name: `${$moduleName}::TradingResponse`, fields: {
+        /** Trading market object id. */
+        market_id: bcs_1.bcs.Address,
+        /** Affected wxa account id. Use this for ownership attribution. */
+        account_id: bcs_1.bcs.Address,
+        /** One of the `waterx_perp::trading::action_*` values. */
+        action: bcs_1.bcs.u8(),
+        /** Execution caller. This can be a keeper or risk manager. */
+        sender: bcs_1.bcs.Address,
+        /** Order id touched or created by the execution, when applicable. */
+        order_id: bcs_1.bcs.option(bcs_1.bcs.u64()),
+        /** Position id touched or created by the execution, when applicable. */
+        position_id: bcs_1.bcs.option(bcs_1.bcs.u64()),
+        /** Raw collateral-token PnL amount. Direction is `pnl_is_profit`. */
+        pnl_amount: bcs_1.bcs.u64(),
+        /** Meaningful only when `pnl_amount > 0`. */
+        pnl_is_profit: bcs_1.bcs.bool(),
+        /** Raw collateral-token fees recorded or realized by this execution. */
+        fee_amount: bcs_1.bcs.u64(),
+        /** Raw collateral amount credited back to the affected wxa account. */
+        returned_collateral_amount: bcs_1.bcs.u64(),
+        /** Raw collateral newly provided by this execution. */
+        input_collateral_amount: bcs_1.bcs.u64(),
+        /** Post-action position collateral, or zero when no position remains. */
+        position_collateral_amount: bcs_1.bcs.u64(),
+        /** Order or position direction for the executed action. */
+        is_long: bcs_1.bcs.bool(),
+        /** Executed or requested size when surfaced by the path; zero if not applicable. */
+        size: float.Float,
+        /** Execution or trigger price when surfaced by the path; zero if not applicable. */
+        execution_price: float.Float
+    } });
+function marketId(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'response',
+        function: 'market_id',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function accountId(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'response',
+        function: 'account_id',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function action(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'response',
+        function: 'action',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function sender(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'response',
+        function: 'sender',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function orderId(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'response',
+        function: 'order_id',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function positionId(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'response',
+        function: 'position_id',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function pnlAmount(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'response',
+        function: 'pnl_amount',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function pnlIsProfit(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'response',
+        function: 'pnl_is_profit',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function feeAmount(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'response',
+        function: 'fee_amount',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function returnedCollateralAmount(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'response',
+        function: 'returned_collateral_amount',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Collateral newly provided by this execution. This is zero for close, cancel,
+ * decrease, withdraw, and liquidation paths.
+ */
+function inputCollateralAmount(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'response',
+        function: 'input_collateral_amount',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Position collateral after this execution, when a position remains or was opened.
+ * This is zero when no position state exists after the action.
+ */
+function positionCollateralAmount(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'response',
+        function: 'position_collateral_amount',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function isLong(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'response',
+        function: 'is_long',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function size(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'response',
+        function: 'size',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function executionPrice(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'response',
+        function: 'execution_price',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Construct a `TradingResponse` receipt. Each dispatch arm in
+ * `waterx_perp::trading` builds exactly one receipt at the tail of the action;
+ * fields not surfaced by a given path are passed as zero / `option::none()` per
+ * the per-field doc comments on the struct. `public(package)` so only this package
+ * can mint receipts — external consumers receive them via the
+ * `vector<TradingResponse>` returns of `trading::execute` and the keeper
+ * entrypoints.
+ */
+function _new(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        '0x2::object::ID',
+        '0x2::object::ID',
+        'u8',
+        'address',
+        '0x1::option::Option<u64>',
+        '0x1::option::Option<u64>',
+        'u64',
+        'bool',
+        'u64',
+        'u64',
+        'u64',
+        'u64',
+        'bool',
+        null,
+        null
+    ];
+    const parameterNames = ["marketId", "accountId", "action", "sender", "orderId", "positionId", "pnlAmount", "pnlIsProfit", "feeAmount", "returnedCollateralAmount", "inputCollateralAmount", "positionCollateralAmount", "isLong", "size", "executionPrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'response',
+        function: 'new',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}