@waterx/sdk 3.0.1 → 3.0.3

package/dist/cjs/src/generated/waterx_prediction/order.js

@@ -0,0 +1,339 @@
+"use strict";
+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.Order = exports.OrderKind = void 0;
+exports.orderId = orderId;
+exports.kind = kind;
+exports.accountId = accountId;
+exports.receiverAccountId = receiverAccountId;
+exports.marketId = marketId;
+exports.selection = selection;
+exports.positionId = positionId;
+exports.maxSpend = maxSpend;
+exports.minShares = minShares;
+exports.priceCap = priceCap;
+exports.minProceeds = minProceeds;
+exports.expiryTs = expiryTs;
+exports.selfCancelAfterTs = selfCancelAfterTs;
+exports.createdTs = createdTs;
+exports.byAdmin = byAdmin;
+exports.isOpen = isOpen;
+exports.isClose = isClose;
+exports.kindIsOpen = kindIsOpen;
+exports.kindIsClose = kindIsClose;
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+const index_ts_1 = require("../utils/index.js");
+const bcs_1 = require("@mysten/sui/bcs");
+const position = __importStar(require("./position.js"));
+const $moduleName = '@waterx/prediction::order';
+exports.OrderKind = new index_ts_1.MoveEnum({ name: `${$moduleName}::OrderKind`, fields: {
+        Open: null,
+        Close: null
+    } });
+exports.Order = new index_ts_1.MoveStruct({ name: `${$moduleName}::Order`, fields: {
+        order_id: bcs_1.bcs.u64(),
+        kind: exports.OrderKind,
+        /**
+         * Account that funded the order and owns pending-order cancellation / refund
+         * rights.
+         */
+        account_id: bcs_1.bcs.Address,
+        /** Account that receives the position after an open order is filled. */
+        receiver_account_id: bcs_1.bcs.Address,
+        market_id: bcs_1.bcs.vector(bcs_1.bcs.u8()),
+        selection: position.Selection,
+        /** `Some(position_id)` only for close orders. */
+        position_id: bcs_1.bcs.option(bcs_1.bcs.u64()),
+        /** Open-order spend escrowed in `MarketRegistry.balance`. */
+        max_spend: bcs_1.bcs.u64(),
+        min_shares: bcs_1.bcs.u64(),
+        price_cap: bcs_1.bcs.u64(),
+        /** Close-order slippage floor. */
+        min_proceeds: bcs_1.bcs.u64(),
+        expiry_ts: bcs_1.bcs.u64(),
+        /** Earliest timestamp at which the account owner may self-cancel. */
+        self_cancel_after_ts: bcs_1.bcs.u64(),
+        created_ts: bcs_1.bcs.u64(),
+        by_admin: bcs_1.bcs.bool()
+    } });
+function orderId(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["order"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'order',
+        function: 'order_id',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function kind(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["order"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'order',
+        function: 'kind',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function accountId(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["order"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'order',
+        function: 'account_id',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function receiverAccountId(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["order"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'order',
+        function: 'receiver_account_id',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function marketId(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["order"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'order',
+        function: 'market_id',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function selection(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["order"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'order',
+        function: 'selection',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function positionId(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["order"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'order',
+        function: 'position_id',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function maxSpend(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["order"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'order',
+        function: 'max_spend',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function minShares(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["order"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'order',
+        function: 'min_shares',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function priceCap(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["order"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'order',
+        function: 'price_cap',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function minProceeds(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["order"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'order',
+        function: 'min_proceeds',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function expiryTs(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["order"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'order',
+        function: 'expiry_ts',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function selfCancelAfterTs(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["order"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'order',
+        function: 'self_cancel_after_ts',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function createdTs(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["order"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'order',
+        function: 'created_ts',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function byAdmin(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["order"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'order',
+        function: 'by_admin',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function isOpen(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["order"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'order',
+        function: 'is_open',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function isClose(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["order"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'order',
+        function: 'is_close',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function kindIsOpen(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["kind"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'order',
+        function: 'kind_is_open',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function kindIsClose(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["kind"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'order',
+        function: 'kind_is_close',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}

package/dist/cjs/src/generated/waterx_prediction/outcome.d.ts

@@ -0,0 +1,58 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveEnum } from '../utils/index.ts';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+export declare const Outcome: MoveEnum<{
+    No: null;
+    Yes: null;
+    Invalid: null;
+}, "@waterx/prediction::outcome::Outcome">;
+export interface NoOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function no(options?: NoOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface YesOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function yes(options?: YesOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface InvalidOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function invalid(options?: InvalidOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsNoArguments {
+    outcome: TransactionArgument;
+}
+export interface IsNoOptions {
+    package?: string;
+    arguments: IsNoArguments | [
+        outcome: TransactionArgument
+    ];
+}
+export declare function isNo(options: IsNoOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsYesArguments {
+    outcome: TransactionArgument;
+}
+export interface IsYesOptions {
+    package?: string;
+    arguments: IsYesArguments | [
+        outcome: TransactionArgument
+    ];
+}
+export declare function isYes(options: IsYesOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsInvalidArguments {
+    outcome: TransactionArgument;
+}
+export interface IsInvalidOptions {
+    package?: string;
+    arguments: IsInvalidArguments | [
+        outcome: TransactionArgument
+    ];
+}
+export declare function isInvalid(options: IsInvalidOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;

package/dist/cjs/src/generated/waterx_prediction/outcome.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Outcome = void 0;
+exports.no = no;
+exports.yes = yes;
+exports.invalid = invalid;
+exports.isNo = isNo;
+exports.isYes = isYes;
+exports.isInvalid = isInvalid;
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+const index_ts_1 = require("../utils/index.js");
+const $moduleName = '@waterx/prediction::outcome';
+exports.Outcome = new index_ts_1.MoveEnum({ name: `${$moduleName}::Outcome`, fields: {
+        No: null,
+        Yes: null,
+        Invalid: null
+    } });
+function no(options = {}) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'outcome',
+        function: 'no',
+    });
+}
+function yes(options = {}) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'outcome',
+        function: 'yes',
+    });
+}
+function invalid(options = {}) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'outcome',
+        function: 'invalid',
+    });
+}
+function isNo(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["outcome"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'outcome',
+        function: 'is_no',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function isYes(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["outcome"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'outcome',
+        function: 'is_yes',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function isInvalid(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["outcome"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'outcome',
+        function: 'is_invalid',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}

package/dist/cjs/src/generated/waterx_prediction/position.d.ts

@@ -0,0 +1,175 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveEnum, MoveStruct } from '../utils/index.ts';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+/**
+ * Which outcome the user predicted. The broker module routes fills externally; it
+ * does not expose a native CLOB direction.
+ */
+export declare const Selection: MoveEnum<{
+    No: null;
+    Yes: null;
+}, "@waterx/prediction::position::Selection">;
+export declare const Position: MoveStruct<{
+    /** Canonical waterx_account that owns this broker position. */
+    account_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    market_id: import("@mysten/sui/bcs").BcsType<number[], Iterable<number> & {
+        length: number;
+    }, string>;
+    selection: MoveEnum<{
+        No: null;
+        Yes: null;
+    }, "@waterx/prediction::position::Selection">;
+    filled_shares: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    filled_cost: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    opened_ts: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    /** Set only while a close order is waiting for keeper execution. */
+    close_order_id: import("@mysten/sui/bcs").BcsType<string | null, string | number | bigint | null | undefined, "Option<u64>">;
+}, "@waterx/prediction::position::Position">;
+export declare const Status: MoveEnum<{
+    Open: null;
+    PendingClose: null;
+}, "@waterx/prediction::position::Status">;
+export interface AccountIdArguments {
+    position: TransactionArgument;
+}
+export interface AccountIdOptions {
+    package?: string;
+    arguments: AccountIdArguments | [
+        position: TransactionArgument
+    ];
+}
+export declare function accountId(options: AccountIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MarketIdArguments {
+    position: TransactionArgument;
+}
+export interface MarketIdOptions {
+    package?: string;
+    arguments: MarketIdArguments | [
+        position: TransactionArgument
+    ];
+}
+export declare function marketId(options: MarketIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SelectionArguments {
+    position: TransactionArgument;
+}
+export interface SelectionOptions {
+    package?: string;
+    arguments: SelectionArguments | [
+        position: TransactionArgument
+    ];
+}
+export declare function selection(options: SelectionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface FilledSharesArguments {
+    position: TransactionArgument;
+}
+export interface FilledSharesOptions {
+    package?: string;
+    arguments: FilledSharesArguments | [
+        position: TransactionArgument
+    ];
+}
+export declare function filledShares(options: FilledSharesOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface FilledCostArguments {
+    position: TransactionArgument;
+}
+export interface FilledCostOptions {
+    package?: string;
+    arguments: FilledCostArguments | [
+        position: TransactionArgument
+    ];
+}
+export declare function filledCost(options: FilledCostOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OpenedTsArguments {
+    position: TransactionArgument;
+}
+export interface OpenedTsOptions {
+    package?: string;
+    arguments: OpenedTsArguments | [
+        position: TransactionArgument
+    ];
+}
+export declare function openedTs(options: OpenedTsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CloseOrderIdArguments {
+    position: TransactionArgument;
+}
+export interface CloseOrderIdOptions {
+    package?: string;
+    arguments: CloseOrderIdArguments | [
+        position: TransactionArgument
+    ];
+}
+export declare function closeOrderId(options: CloseOrderIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface HasPendingCloseArguments {
+    position: TransactionArgument;
+}
+export interface HasPendingCloseOptions {
+    package?: string;
+    arguments: HasPendingCloseArguments | [
+        position: TransactionArgument
+    ];
+}
+export declare function hasPendingClose(options: HasPendingCloseOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface StatusArguments {
+    position: TransactionArgument;
+}
+export interface StatusOptions {
+    package?: string;
+    arguments: StatusArguments | [
+        position: TransactionArgument
+    ];
+}
+export declare function status(options: StatusOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SelectionNoOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function selectionNo(options?: SelectionNoOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SelectionYesOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function selectionYes(options?: SelectionYesOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface StatusIsOpenArguments {
+    s: TransactionArgument;
+}
+export interface StatusIsOpenOptions {
+    package?: string;
+    arguments: StatusIsOpenArguments | [
+        s: TransactionArgument
+    ];
+}
+export declare function statusIsOpen(options: StatusIsOpenOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface StatusIsPendingCloseArguments {
+    s: TransactionArgument;
+}
+export interface StatusIsPendingCloseOptions {
+    package?: string;
+    arguments: StatusIsPendingCloseArguments | [
+        s: TransactionArgument
+    ];
+}
+export declare function statusIsPendingClose(options: StatusIsPendingCloseOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SelectionIsNoArguments {
+    s: TransactionArgument;
+}
+export interface SelectionIsNoOptions {
+    package?: string;
+    arguments: SelectionIsNoArguments | [
+        s: TransactionArgument
+    ];
+}
+export declare function selectionIsNo(options: SelectionIsNoOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SelectionIsYesArguments {
+    s: TransactionArgument;
+}
+export interface SelectionIsYesOptions {
+    package?: string;
+    arguments: SelectionIsYesArguments | [
+        s: TransactionArgument
+    ];
+}
+export declare function selectionIsYes(options: SelectionIsYesOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;