@waterx/sdk 4.0.1 → 4.1.0

package/dist/cjs/src/perp/user/wlp.js

@@ -51,6 +51,7 @@ exports.settleRedeemWlp = settleRedeemWlp;
 exports.updateTokenValue = updateTokenValue;
 const account_request_ts_1 = require("../../account/account-request.js");
 const lp = __importStar(require("../../generated/waterx_perp/lp_pool.js"));
+const validate_ts_1 = require("../../utils/validate.js");
 /** Returns the minted `lp_amount` so it can be chained into e.g. `stake`. */
 function mintWlp(client, tx, params) {
     const req = (0, account_request_ts_1.makeSenderRequest)(client, tx, params.bucketAccount);
@@ -63,8 +64,8 @@ function mintWlp(client, tx, params) {
             aum: tx.object(requireWlpAum(client)),
             senderRequest: req,
             accountId: params.accountId,
-            depositAmount: params.depositAmount,
-            minLpAmount: params.minLpAmount,
+            depositAmount: (0, validate_ts_1.toU64)(params.depositAmount, "depositAmount"),
+            minLpAmount: (0, validate_ts_1.toU64)(params.minLpAmount, "minLpAmount"),
             oracle: tx.object(client.config.packages.waterx_oracle.oracle),
         },
         typeArguments: [params.lpType ?? client.wlpType(), params.depositTokenType],
@@ -88,7 +89,7 @@ function requestRedeemWlp(client, tx, params) {
             wxaRegistry: tx.object(client.config.packages.waterx_account.account_registry),
             senderRequest: req,
             accountId: params.accountId,
-            lpAmount: params.lpAmount,
+            lpAmount: (0, validate_ts_1.toU64)(params.lpAmount, "lpAmount"),
         },
         typeArguments: [params.lpType ?? client.wlpType(), params.redeemTokenType],
     })(tx);
@@ -102,7 +103,7 @@ function cancelRedeemWlp(client, tx, params) {
             globalConfig: tx.object(client.config.packages.waterx_perp.global_config),
             wxaRegistry: tx.object(client.config.packages.waterx_account.account_registry),
             senderRequest: req,
-            requestId: params.requestId,
+            requestId: (0, validate_ts_1.toU64)(params.requestId, "requestId"),
         },
         typeArguments: [params.lpType ?? client.wlpType()],
     })(tx);
@@ -117,7 +118,7 @@ function settleRedeemWlp(client, tx, params) {
             wxaRegistry: tx.object(client.config.packages.waterx_account.account_registry),
             operatorRequest: req,
             aum: tx.object(requireWlpAum(client)),
-            requestId: params.requestId,
+            requestId: (0, validate_ts_1.toU64)(params.requestId, "requestId"),
             oracle: tx.object(client.config.packages.waterx_oracle.oracle),
         },
         typeArguments: [params.lpType ?? client.wlpType(), params.redeemTokenType],

package/dist/cjs/src/prediction/utils.d.ts

@@ -10,8 +10,17 @@ export declare function resolveSettlementCoinType(client: PredictClient, coinTyp
 export declare function resolveMarketRegistry(client: PredictClient, marketRegistry?: string): string;
 export declare function resolveAccountRegistry(client: PredictClient, accountRegistry?: string): string;
 export declare function resolveGlobalConfig(client: PredictClient, globalConfig?: string): string;
-/** Ensures `value` is a valid unsigned 64-bit integer. */
-export declare function assertU64(value: bigint, name?: string): bigint;
+/**
+ * Ensures `value` is a valid unsigned 64-bit integer.
+ *
+ * Thin alias for the shared `utils/validate.toU64` — the u64 domain rule
+ * (bigint range check; a `number` must be a NON-NEGATIVE SAFE integer, since
+ * `2^53 + 2` passes `isInteger` yet has already lost f64 precision and would
+ * BCS-encode a silently-wrong value) is authored ONCE there for both product
+ * lines. Throws `RangeError` (a subclass of `Error`) naming the parameter.
+ */
+export declare function assertU64(value: bigint | number, name?: string): bigint;
+/** Normalize a u64-ish input (bigint / number / decimal string) to a checked `bigint`. */
 export declare function toBigInt(value: bigint | number | string): bigint;
 export declare function objectArg(tx: Transaction, value: ObjectArgument): TransactionArgument;
 export declare function idArg(tx: Transaction, value: IdArgument): TransactionArgument;

package/dist/cjs/src/prediction/utils.js

@@ -21,10 +21,11 @@ exports.marketIdArg = marketIdArg;
 exports.bytesToHex = bytesToHex;
 exports.optionU64 = optionU64;
 exports.receivingCoinArg = receivingCoinArg;
+const validate_ts_1 = require("../utils/validate.js");
 const constants_ts_1 = require("./constants.js");
 const SELECTIONS = ["YES", "NO"];
 const OUTCOMES = ["YES", "NO", "INVALID"];
-const U64_MAX = (1n << 64n) - 1n;
+const DECIMAL_INT_RE = /^\d+$/;
 function assertSelection(value) {
     if (SELECTIONS.includes(value))
         return value;
@@ -68,32 +69,31 @@ function resolveAccountRegistry(client, accountRegistry) {
 function resolveGlobalConfig(client, globalConfig) {
     return globalConfig === undefined || globalConfig === "" ? client.globalConfigId() : globalConfig;
 }
-/** Ensures `value` is a valid unsigned 64-bit integer. */
+/**
+ * Ensures `value` is a valid unsigned 64-bit integer.
+ *
+ * Thin alias for the shared `utils/validate.toU64` — the u64 domain rule
+ * (bigint range check; a `number` must be a NON-NEGATIVE SAFE integer, since
+ * `2^53 + 2` passes `isInteger` yet has already lost f64 precision and would
+ * BCS-encode a silently-wrong value) is authored ONCE there for both product
+ * lines. Throws `RangeError` (a subclass of `Error`) naming the parameter.
+ */
 function assertU64(value, name = "value") {
-    if (value < 0n) {
-        throw new Error(`${name} must be non-negative, got ${value}`);
-    }
-    if (value > U64_MAX) {
-        throw new Error(`${name} exceeds u64 max (${U64_MAX}), got ${value}`);
-    }
-    return value;
+    return (0, validate_ts_1.toU64)(value, name);
 }
+/** Normalize a u64-ish input (bigint / number / decimal string) to a checked `bigint`. */
 function toBigInt(value) {
-    if (typeof value === "bigint") {
+    if (typeof value !== "string")
         return assertU64(value);
-    }
-    if (typeof value === "number") {
-        if (!Number.isInteger(value)) {
-            throw new Error(`Invalid integer: ${value}`);
-        }
-        return assertU64(BigInt(value));
-    }
+    // String is the one form the shared guard does not cover: digits parse exactly
+    // past the 2^53 f64 cliff, so the shape check lives here and the numeric
+    // domain still funnels through assertU64.
     const trimmed = value.trim();
     if (trimmed === "") {
-        throw new Error("Invalid integer: empty string");
+        throw new RangeError("Invalid integer: empty string");
     }
-    if (!/^\d+$/.test(trimmed)) {
-        throw new Error(`Invalid integer: ${JSON.stringify(value)}`);
+    if (!DECIMAL_INT_RE.test(trimmed)) {
+        throw new RangeError(`Invalid integer: ${JSON.stringify(value)}`);
     }
     return assertU64(BigInt(trimmed));
 }
@@ -184,8 +184,8 @@ function optionU64(value) {
 function formatObjectVersion(version) {
     if (typeof version === "string") {
         const trimmed = version.trim();
-        if (trimmed === "" || !/^\d+$/.test(trimmed)) {
-            throw new Error(`Invalid object version: ${JSON.stringify(version)}`);
+        if (trimmed === "" || !DECIMAL_INT_RE.test(trimmed)) {
+            throw new RangeError(`Invalid object version: ${JSON.stringify(version)}`);
         }
         return trimmed;
     }

package/dist/cjs/src/unified-client.d.ts

@@ -34,6 +34,7 @@ import * as perpReferral from "./account/referral.ts";
 import type { Network } from "./constants.ts";
 import type { PythFetchPolicy } from "./oracle/config.ts";
 import type { OracleSource } from "./oracle/price-update-rule.ts";
+import type { FetchPolicy } from "./oracle/update-fetch.ts";
 import { PerpClient, type CreateClientOptions as PerpCreateOptions } from "./perp/client.ts";
 import * as perpFetch from "./perp/fetch.ts";
 import * as perpTx from "./perp/tx-builders.ts";
@@ -90,8 +91,8 @@ declare const perpOps: {
     getPosition(client: PerpClient, args: {
         ticker: string;
         positionId: bigint | number;
-        basePriceUsd: bigint | number;
-        collateralPriceUsd: bigint | number;
+        basePriceUsd: perpFetch.WholeDollarUsdPrice;
+        collateralPriceUsd: perpFetch.WholeDollarUsdPrice;
         lpType?: string;
     }): Promise<perpFetch.PositionDataView>;
     getOrder(client: PerpClient, args: {
@@ -99,12 +100,12 @@ declare const perpOps: {
         orderId: bigint | number;
         orderTypeTag: number;
         triggerPrice: bigint | number;
-        basePriceUsd: bigint | number;
+        basePriceUsd: perpFetch.WholeDollarUsdPrice;
         lpType?: string;
     }): Promise<perpFetch.OrderDataView>;
     getMarketOrders(client: PerpClient, args: {
         ticker: string;
-        basePriceUsd?: bigint | number;
+        basePriceUsd?: perpFetch.WholeDollarUsdPrice;
         lpType?: string;
     } & perpFetch.PageOpts): Promise<{
         orders: perpFetch.OrderDataView[];
@@ -112,8 +113,8 @@ declare const perpOps: {
     }>;
     getMarketPositions(client: PerpClient, args: {
         ticker: string;
-        basePriceUsd: bigint | number;
-        collateralPriceUsd?: bigint | number;
+        basePriceUsd: perpFetch.WholeDollarUsdPrice;
+        collateralPriceUsd?: perpFetch.WholeDollarUsdPrice;
         lpType?: string;
     } & perpFetch.PageOpts): Promise<{
         positions: perpFetch.PositionDataView[];
@@ -122,14 +123,14 @@ declare const perpOps: {
     getAccountPositions(client: PerpClient, args: {
         ticker: string;
         accountObjectAddress: string;
-        basePriceUsd: bigint | number;
-        collateralPriceUsd?: bigint | number;
+        basePriceUsd: perpFetch.WholeDollarUsdPrice;
+        collateralPriceUsd?: perpFetch.WholeDollarUsdPrice;
         lpType?: string;
     }): Promise<perpFetch.PositionDataView[]>;
     getAccountOrders(client: PerpClient, args: {
         ticker: string;
         accountObjectAddress: string;
-        basePriceUsd?: bigint | number;
+        basePriceUsd?: perpFetch.WholeDollarUsdPrice;
         lpType?: string;
     }): Promise<perpFetch.OrderDataView[]>;
     getRedeemRequests(client: PerpClient, args?: {
@@ -138,6 +139,7 @@ declare const perpOps: {
         requests: perpFetch.RedeemRequestDataView[];
         nextCursor?: bigint;
     }>;
+    parseWholeDollarU64: typeof perpFetch.parseWholeDollarU64;
     getAccountsByOwner(client: PerpClient, owner: string): Promise<string[]>;
     getAccountBalance(client: PerpClient, accountId: string, coinType?: string): Promise<bigint>;
     getSpendableCreditBalance(client: PerpClient, accountId: string): Promise<perpFetch.SpendableCreditBalance>;
@@ -368,11 +370,14 @@ export interface ClientCreateOptions {
     /**
      * The perp line's oracle price-update source (perp-line only — the
      * prediction line has no oracle leg), forwarded to `PerpClient.create`.
-     * Source-neutral by design: a future source need not be Pyth.
+     * Source-neutral by design: a source need not be Pyth (see `'waterx_rule'`).
      *
      * - `'pyth_rule'` (default) — Pyth Core updates on Core infra.
      * - `'pyth_lazer_rule'` — Pyth Lazer signed updates (pair with `pythApiKey`
      *   and a config carrying `packages.pyth_lazer_rule`).
+     * - `'waterx_rule'` — the first-party WaterX quote-center (Nautilus-TEE,
+     *   ed25519 signed batches; no credential, no per-update fee). Pair with
+     *   `waterxEndpoint` / `waterxFetch` when the browser needs a proxy.
      *
      * Each source is self-contained with no cross-source fallback; selecting a
      * source whose feed for a ticker is absent fails at tx-build (not at init).
@@ -388,6 +393,22 @@ export interface ClientCreateOptions {
     pythApiKey?: string;
     /** Retry/timeout policy for the perp line's off-chain oracle fetches. */
     pythFetch?: PythFetchPolicy;
+    /**
+     * Quote-center base URL for `oracleSource: 'waterx_rule'`, forwarded to the
+     * perp line — overrides the per-network `WATERX_DEFAULTS` host.
+     *
+     * `waterx_rule` is the one source a BROWSER fetches itself, so it is bound by
+     * the quote-center deployment's CORS allowlist: a front end whose origin is
+     * not allowed points this at its own same-origin proxy. An absolute URL whose
+     * base PATH is preserved — `https://app.example/api/quote-center` fetches
+     * `…/api/quote-center/v1/quotes/update`. Unused by the Pyth sources.
+     */
+    waterxEndpoint?: string;
+    /**
+     * Retry/timeout policy — and `fetchImpl` — for the perp line's quote-center
+     * fetch. Falls back to `pythFetch`, then to the built-in defaults.
+     */
+    waterxFetch?: FetchPolicy;
     /** Perp-line overrides (network, grpcUrl, waterxConfigUrl, cache, …). */
     perp?: PerpLineOptions;
     /** Prediction-line overrides (network, grpcUrl, waterxConfigUrl, cache, settlement, …). */

package/dist/cjs/src/unified-client.js

@@ -207,6 +207,8 @@ class WaterXClient {
             oracleSource: opts.oracleSource,
             pythApiKey: opts.pythApiKey,
             pythFetch: opts.pythFetch,
+            waterxEndpoint: opts.waterxEndpoint,
+            waterxFetch: opts.waterxFetch,
             ...perpRest,
         });
         const predictClient = await client_ts_2.PredictClient.create(resolvedPredictNetwork, {

package/dist/cjs/src/utils/format.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Funding-interval label from milliseconds: hour-based at or above one hour,
+ * minute-based below. Non-integer hours are kept as-is:
+ *
+ *   3_600_000  → "1H"
+ *   28_800_000 → "8H"
+ *   5_400_000  → "1.5H"
+ *   1_800_000  → "30M"
+ *
+ * Single source for the label the BE tickers payload emits and the FE reader
+ * must reproduce byte-identically (output-identical port of bucket-backend-mono
+ * `apps/waterx/src/core/utils/funding.ts::formatFundingInterval`).
+ */
+export declare function formatFundingInterval(intervalMs: number): string;

package/dist/cjs/src/utils/format.js

@@ -0,0 +1,24 @@
+"use strict";
+// Display-label formatters that must be byte-identical wherever the same wire
+// field is rendered. Hosted in the SDK so FE and BE share one implementation
+// instead of hand-mirroring each other.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatFundingInterval = formatFundingInterval;
+const constants_ts_1 = require("../constants.js");
+/**
+ * Funding-interval label from milliseconds: hour-based at or above one hour,
+ * minute-based below. Non-integer hours are kept as-is:
+ *
+ *   3_600_000  → "1H"
+ *   28_800_000 → "8H"
+ *   5_400_000  → "1.5H"
+ *   1_800_000  → "30M"
+ *
+ * Single source for the label the BE tickers payload emits and the FE reader
+ * must reproduce byte-identically (output-identical port of bucket-backend-mono
+ * `apps/waterx/src/core/utils/funding.ts::formatFundingInterval`).
+ */
+function formatFundingInterval(intervalMs) {
+    const hours = intervalMs / constants_ts_1.MS_PER_HOUR;
+    return hours >= 1 ? `${hours}H` : `${intervalMs / constants_ts_1.MS_PER_MINUTE}M`;
+}