@waterx/sdk 4.0.1 → 4.3.0

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

@@ -0,0 +1,183 @@
+"use strict";
+// Numeric-domain guards. One place for the question "is this value inside the
+// domain the callee can honestly compute over?", asked at the three points
+// where garbage enters:
+//
+// 1. INTEGER params (`toU64` / `toU128` / `toU8` / `toU16` + the `*OrNull` /
+//    `toU64Arg` variants) on the fetch AND write (tx-build) surfaces. What the
+//    generated BCS layer does with a bad `number` depends on the width, and at
+//    no width is the answer "throw naming the parameter" (verified against
+//    `@mysten/sui`'s `bcs`):
+//    - u64 / u128 throw on negative and on fractional — but a `number` past
+//      2^53 has already lost precision in JS BEFORE BCS sees it. `2**53 + 1`
+//      collapses to `2**53` at parse time, so BCS faithfully encodes a value
+//      the caller never wrote. (`2**53 + 2` IS exactly representable and
+//      encodes correctly — the hazard is the odd side of the f64 cliff, not
+//      BCS.) Hence the `Number.isSafeInteger` floor here.
+//    - u8 / u16 throw when the value is out of range but SILENTLY TRUNCATE a
+//      fractional one (`bcs.u8().serialize(2.7)` encodes `2`), so the
+//      fractional case is the one only a guard can catch.
+//    Every integer param funnels through these so garbage throws with the
+//    parameter's name before a transaction is built.
+// 2. FLOAT / BIGINT domains (`assertFinite` / `assertFiniteNonNegative` /
+//    `assertUnitFraction` / `assertTokenDecimal` / `assertUnsignedBigInt`) for
+//    the money-path math in `utils/math.ts`.
+// 3. The WHOLE-DOLLAR USD price domain (`WholeDollarUsdPrice` /
+//    `parseWholeDollarU64`) the `waterx_perp_view` read params live in.
+//
+// Families 2 and 3 live HERE rather than privately inside `math.ts` /
+// `perp/fetch/positions.ts` so the whole numeric-domain vocabulary is
+// discoverable in one file: hiding it is why `parseWholeDollarU64` once
+// re-derived `toU64`'s entire chain (finite → integer → safe integer →
+// non-negative → <= u64::MAX) by hand.
+//
+// Everything throws `RangeError` naming the offending parameter.
+//
+// Visibility: this module is internal EXCEPT for the whole-dollar pair, which
+// is public and re-exported from `perp/fetch/positions.ts` (→ the `perp/fetch`
+// barrel → `@waterx/sdk`) — that is the published import path, not this file.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.U64_MAX = void 0;
+exports.toU64 = toU64;
+exports.toU128 = toU128;
+exports.toU8 = toU8;
+exports.toU16 = toU16;
+exports.toU64OrNull = toU64OrNull;
+exports.toU128OrNull = toU128OrNull;
+exports.toU64Arg = toU64Arg;
+exports.assertFinite = assertFinite;
+exports.assertFiniteNonNegative = assertFiniteNonNegative;
+exports.assertUnitFraction = assertUnitFraction;
+exports.assertTokenDecimal = assertTokenDecimal;
+exports.assertUnsignedBigInt = assertUnsignedBigInt;
+exports.parseWholeDollarU64 = parseWholeDollarU64;
+exports.U64_MAX = 18446744073709551615n; // 2^64 − 1
+const U128_MAX = 340282366920938463463374607431768211455n; // 2^128 − 1
+function toUint(value, label, max, width) {
+    let v;
+    if (typeof value === "bigint") {
+        v = value;
+    }
+    else {
+        if (!Number.isSafeInteger(value) || value < 0) {
+            throw new RangeError(`${label} must be a non-negative safe integer (< 2^53) or a bigint, got ${value}`);
+        }
+        v = BigInt(value);
+    }
+    if (v < 0n || v > max) {
+        throw new RangeError(`${label} out of ${width} range, got ${v}`);
+    }
+    return v;
+}
+/** Validate a u64 param (bigint passthrough with range check; number must be a safe integer >= 0). */
+function toU64(value, label) {
+    return toUint(value, label, exports.U64_MAX, "u64");
+}
+/** Validate a u128 param (bigint passthrough with range check; number must be a safe integer >= 0). */
+function toU128(value, label) {
+    return toUint(value, label, U128_MAX, "u128");
+}
+function toSmallUint(value, label, max, width) {
+    if (!Number.isInteger(value) || value < 0 || value > max) {
+        throw new RangeError(`${label} must be an integer in [0, ${max}] (${width}), got ${value}`);
+    }
+    return value;
+}
+/**
+ * Validate a u8 param. Returns a `number` (not a bigint) because that is the
+ * shape the generated BCS layer takes at this width.
+ *
+ * Separate from `toU64` on purpose: at u8/u16 the BCS writer already throws on
+ * an out-of-range value, but SILENTLY TRUNCATES a fractional one — so the
+ * fractional case is what this guard exists to catch (see the header note).
+ */
+function toU8(value, label) {
+    return toSmallUint(value, label, 0xff, "u8");
+}
+/** Validate a u16 param. Same width caveat as {@link toU8}. */
+function toU16(value, label) {
+    return toSmallUint(value, label, 0xffff, "u16");
+}
+/** `Option<u64>` param: `null` / `undefined` pass through as `null`, anything else is validated. */
+function toU64OrNull(value, label) {
+    return value == null ? null : toU64(value, label);
+}
+/** `Option<u128>` param: `null` / `undefined` pass through as `null`, anything else is validated. */
+function toU128OrNull(value, label) {
+    return value == null ? null : toU128(value, label);
+}
+/**
+ * u64 param that may instead be a PTB result chained from an earlier command
+ * (e.g. the `lp_amount` returned by `mintWlp`). A `TransactionArgument` passes
+ * through untouched — its value only exists on chain, where Move types it.
+ */
+function toU64Arg(value, label) {
+    return typeof value === "bigint" || typeof value === "number" ? toU64(value, label) : value;
+}
+// NOTE: there is deliberately no `toU128Arg`. No write builder exposes a u128
+// param that can take a chained `TransactionArgument` (every u128 site — size /
+// trigger price / acceptable price — is a caller-supplied literal), so a u128
+// half of `toU64Arg` would be an export with no consumer. Add it back the day a
+// builder actually chains a u128 PTB result.
+/** Reject NaN / ±Infinity for a `number` money-path input. */
+function assertFinite(label, value) {
+    if (!Number.isFinite(value)) {
+        throw new RangeError(`${label} must be a finite number, got ${value}`);
+    }
+}
+/** Reject NaN / ±Infinity / negative for a `number` money-path input. */
+function assertFiniteNonNegative(label, value) {
+    assertFinite(label, value);
+    if (value < 0) {
+        throw new RangeError(`${label} must be >= 0, got ${value}`);
+    }
+}
+/**
+ * Reject anything outside `[0, 1]` for a `number` input that is a FRACTION of a
+ * whole — a maintenance-margin rate above 1 means "maintenance exceeds the
+ * entire notional", which is not a rate the caller can have meant.
+ */
+function assertUnitFraction(label, value) {
+    assertFinite(label, value);
+    if (value < 0 || value > 1) {
+        throw new RangeError(`${label} must be within [0, 1], got ${value}`);
+    }
+}
+/**
+ * Reject a token-decimal outside `[0, 19]` — the domain of the contract's
+ * `10u64.pow(decimal)` (`10^19 < 2^64 <= 10^20`), and the same bound the raw
+ * `POW10` table in `utils/math.ts` is built over.
+ */
+function assertTokenDecimal(label, value) {
+    if (!Number.isInteger(value) || value < 0 || value > 19) {
+        throw new RangeError(`${label} must be an integer in [0, 19], got ${value}`);
+    }
+}
+/** Reject a negative `bigint` where the on-chain type is unsigned. */
+function assertUnsignedBigInt(label, value) {
+    if (value < 0n) {
+        throw new RangeError(`${label} must be >= 0, got ${value}`);
+    }
+}
+const PLAIN_INT_RE = /^-?\d+$/;
+/**
+ * Parse a user/env-supplied value into a whole-dollar u64 price
+ * (`WholeDollarUsdPrice`) with NO silent rounding: throws `RangeError` on
+ * fractional, negative, non-finite, non-numeric, or `> u64::MAX` input. If
+ * rounding is ever wanted it must be explicit at the call site
+ * (e.g. `parseWholeDollarU64(Math.round(x))`) — never baked in here.
+ *
+ * The numeric domain (finite → safe integer → non-negative → `<= u64::MAX`) is
+ * `toU64`'s and is NOT restated here; this function only adds the string form,
+ * whose digits parse exactly past the 2^53 f64 cliff.
+ */
+function parseWholeDollarU64(value) {
+    const label = "whole-dollar USD price";
+    if (typeof value !== "string")
+        return toU64(value, label);
+    const trimmed = value.trim();
+    if (!PLAIN_INT_RE.test(trimmed)) {
+        throw new RangeError(`${label} must be a plain integer string, got "${value}"`);
+    }
+    return toU64(BigInt(trimmed), label);
+}

package/dist/src/account/account.js

@@ -11,6 +11,7 @@
  * or a `TransactionArgument`).
  */
 import * as wxa from "../generated/waterx_account/account.js";
+import { toU64 } from "../utils/validate.js";
 import { makeSenderRequest } from "./account-request.js";
 import { ACCUMULATOR_ROOT } from "./constants.js";
 import { createAccountCall } from "./waterx-account.js";
@@ -149,7 +150,7 @@ export function requestWithdraw(client, tx, params) {
             registry: tx.object(client.config.packages.waterx_account.account_registry),
             senderRequest: req,
             accountId: params.accountId,
-            amount: params.amount,
+            amount: toU64(params.amount, "amount"),
             recipient: params.recipient,
             extraData: Array.from(params.extraData ?? new Uint8Array()),
         },

package/dist/src/account/config.d.ts

@@ -73,8 +73,9 @@ export interface WithdrawalQueuePackage {
 /**
  * Wormhole infra for the cross-chain credit bridge. `state_id` is the same
  * shared Sui Wormhole `State` object Pyth uses (kept in sync with
- * `PYTH_DEFAULTS[*].wormhole_state_id`). Override per-deployment via
- * `WaterXConfig.wormhole` if a deployment ever points elsewhere.
+ * `PYTH_CORE_INFRA[*].wormhole_state_id` in `oracle/pyth.ts`). Override
+ * per-deployment via `WaterXConfig.wormhole` if a deployment ever points
+ * elsewhere.
  */
 export interface WormholeInfraConfig {
     /** Shared Sui Wormhole `State` object. */

package/dist/src/account/funding/balance.d.ts

@@ -15,7 +15,15 @@ export interface ParkedBackingAssetBalance {
     /** Sum of `listCoins` object balances — TTO'd / owned `Coin<T>` path. */
     coinsRaw: bigint;
 }
-/** Rescale a u64 raw amount between token decimal precisions (truncates on downscale). */
+/**
+ * Rescale a u64 raw amount between token decimal precisions (truncates on
+ * downscale). `toDecimals` defaults to {@link COLLATERAL_DECIMALS} — the
+ * CREDIT/wxUSD (collateral-typed) scale, 6 on every current deployment — for
+ * the common backing-asset → CREDIT direction. When rescaling a custody
+ * backing asset, always pass its per-asset config `decimal`
+ * (`NativeCustodyAsset.decimal`) as `fromDecimals`; never assume flat 6 — a
+ * 9-dec backing asset would otherwise mis-scale by 1000×.
+ */
 export declare function rescaleRawAmount(raw: bigint, fromDecimals: number, toDecimals?: number): bigint;
 /**
  * Probe every backing asset registered on `native_custody` for non-zero balances
@@ -26,7 +34,22 @@ export declare function probeParkedBackingAssets(client: AccountClientLike, acco
 /**
  * Probe non-zero CREDIT parked at `accountId`'s Sui address. Matches the
  * address-CREDIT legs inside {@link appendConsolidateAddressCredit}.
+ *
+ * RPC failures PROPAGATE (no swallow-to-zero): a gRPC error here used to be
+ * silently reported as an authoritative zero balance, which made
+ * `getSpendableCreditBalance` under-report spendable funds and let
+ * `appendConsolidateAddressCredit` build a tx that later aborted on-chain
+ * with a confusing insufficient-balance error. Callers that can tolerate a
+ * missing probe must catch explicitly.
  */
 export declare function probeAddressCreditBalance(client: AccountClientLike, accountId: string): Promise<AddressCreditBalance>;
-/** Sum parked backing assets into CREDIT base units at the 1:1 PSM peg. */
+/**
+ * Sum parked backing assets into CREDIT base units at the 1:1 PSM peg.
+ * Each row rescales from its own per-asset `decimals` (sourced from config
+ * `NativeCustodyAsset.decimal` by {@link probeParkedBackingAssets}), so
+ * mixed-decimal backing sets (e.g. a 9-dec asset next to 6-dec USDC) sum
+ * correctly. `creditDecimals` is the CREDIT/wxUSD **target** scale —
+ * collateral-typed, 6 on all current deployments (the config JSON carries no
+ * credit decimal).
+ */
 export declare function sumParkedBackingAsCreditRaw(parked: readonly ParkedBackingAssetBalance[], creditDecimals?: number): bigint;

package/dist/src/account/funding/balance.js

@@ -4,7 +4,15 @@
  * so display totals match what the next async tx-builder would sweep.
  */
 import { COLLATERAL_DECIMALS } from "../../constants.js";
-/** Rescale a u64 raw amount between token decimal precisions (truncates on downscale). */
+/**
+ * Rescale a u64 raw amount between token decimal precisions (truncates on
+ * downscale). `toDecimals` defaults to {@link COLLATERAL_DECIMALS} — the
+ * CREDIT/wxUSD (collateral-typed) scale, 6 on every current deployment — for
+ * the common backing-asset → CREDIT direction. When rescaling a custody
+ * backing asset, always pass its per-asset config `decimal`
+ * (`NativeCustodyAsset.decimal`) as `fromDecimals`; never assume flat 6 — a
+ * 9-dec backing asset would otherwise mis-scale by 1000×.
+ */
 export function rescaleRawAmount(raw, fromDecimals, toDecimals = COLLATERAL_DECIMALS) {
     if (fromDecimals === toDecimals)
         return raw;
@@ -52,39 +60,43 @@ export async function probeParkedBackingAssets(client, accountId) {
 /**
  * Probe non-zero CREDIT parked at `accountId`'s Sui address. Matches the
  * address-CREDIT legs inside {@link appendConsolidateAddressCredit}.
+ *
+ * RPC failures PROPAGATE (no swallow-to-zero): a gRPC error here used to be
+ * silently reported as an authoritative zero balance, which made
+ * `getSpendableCreditBalance` under-report spendable funds and let
+ * `appendConsolidateAddressCredit` build a tx that later aborted on-chain
+ * with a confusing insufficient-balance error. Callers that can tolerate a
+ * missing probe must catch explicitly.
  */
 export async function probeAddressCreditBalance(client, accountId) {
     if (!client.config.packages.waterx_credit?.credit_type) {
         return { fundsRaw: 0n, coinsRaw: 0n };
     }
     const creditType = client.creditType();
-    let fundsRaw = 0n;
+    const bal = (await client.getBalance({
+        owner: accountId,
+        coinType: creditType,
+    }));
+    const fundsRaw = BigInt(bal.balance?.addressBalance ?? "0");
+    const coins = (await client.listCoins({
+        owner: accountId,
+        coinType: creditType,
+    }));
     let coinsRaw = 0n;
-    try {
-        const bal = (await client.getBalance({
-            owner: accountId,
-            coinType: creditType,
-        }));
-        fundsRaw = BigInt(bal.balance?.addressBalance ?? "0");
-    }
-    catch {
-        // ignore — treat as zero parked funds
-    }
-    try {
-        const coins = (await client.listCoins({
-            owner: accountId,
-            coinType: creditType,
-        }));
-        for (const coin of coins.objects ?? []) {
-            coinsRaw += BigInt(coin.balance ?? "0");
-        }
-    }
-    catch {
-        // ignore — treat as zero owned coins
+    for (const coin of coins.objects ?? []) {
+        coinsRaw += BigInt(coin.balance ?? "0");
     }
     return { fundsRaw, coinsRaw };
 }
-/** Sum parked backing assets into CREDIT base units at the 1:1 PSM peg. */
+/**
+ * Sum parked backing assets into CREDIT base units at the 1:1 PSM peg.
+ * Each row rescales from its own per-asset `decimals` (sourced from config
+ * `NativeCustodyAsset.decimal` by {@link probeParkedBackingAssets}), so
+ * mixed-decimal backing sets (e.g. a 9-dec asset next to 6-dec USDC) sum
+ * correctly. `creditDecimals` is the CREDIT/wxUSD **target** scale —
+ * collateral-typed, 6 on all current deployments (the config JSON carries no
+ * credit decimal).
+ */
 export function sumParkedBackingAsCreditRaw(parked, creditDecimals = COLLATERAL_DECIMALS) {
     let sum = 0n;
     for (const row of parked) {

package/dist/src/account/funding/credit.js

@@ -24,6 +24,7 @@ import { requestWithdraw as requestWithdrawCall } from "../../generated/waterx_a
 import { consumeDepositDirect } from "../../generated/waterx_account/direct_rule.js";
 import { enqueue as enqueueCall, executeNative as executeNativeCall, executeWormhole as executeWormholeCall, routeNative as routeNativeCall, routeWormhole as routeWormholeCall, } from "../../generated/withdrawal_queue/withdrawal_queue.js";
 import { redeemVaa as redeemVaaCall } from "../../generated/wormhole_bridge/wormhole_bridge.js";
+import { toU16, toU64 } from "../../utils/validate.js";
 import { makeSenderRequest } from "../account-request.js";
 // ============================================================================
 // Byte helpers
@@ -126,15 +127,10 @@ export function consumeCreditDeposit(client, tx, params) {
 }
 /** Build `withdrawal_queue::route_wormhole`. Returns the `extra_data` argument. */
 export function routeWormhole(client, tx, params) {
-    if (!Number.isInteger(params.evmDestinationChain) ||
-        params.evmDestinationChain < 0 ||
-        params.evmDestinationChain > 0xffff) {
-        throw new Error(`evmDestinationChain must be a u16 (0..65535), got ${params.evmDestinationChain}`);
-    }
     const out = routeWormholeCall({
         package: queuePkg(client),
         arguments: {
-            evmDestinationChain: params.evmDestinationChain,
+            evmDestinationChain: toU16(params.evmDestinationChain, "evmDestinationChain"),
             evmRecipient: toEvmAddressBytes(params.evmRecipient, "evmRecipient"),
             evmToken: toEvmAddressBytes(params.evmToken, "evmToken"),
         },
@@ -145,7 +141,7 @@ export function routeWormhole(client, tx, params) {
 export function routeNative(client, tx, params) {
     const out = routeNativeCall({
         package: queuePkg(client),
-        arguments: { minOutput: BigInt(params.minOutput ?? 0n) },
+        arguments: { minOutput: toU64(params.minOutput ?? 0n, "minOutput") },
         typeArguments: [normalizeStructTag(params.assetType)],
     })(tx);
     return out;
@@ -163,7 +159,7 @@ export function requestCreditWithdraw(client, tx, params) {
             registry: tx.object(client.config.packages.waterx_account.account_registry),
             senderRequest: senderRequest,
             accountId: params.accountId,
-            amount: params.amount,
+            amount: toU64(params.amount, "amount"),
             recipient: params.recipient,
             extraData: params.route,
         },
@@ -194,7 +190,7 @@ export function executeWithdrawalWormhole(client, tx, params) {
         package: queuePkg(client),
         arguments: {
             queue: tx.object(queueId(client)),
-            key: params.key,
+            key: toU64(params.key, "key"),
             request: request,
             bridge: tx.object(bridgeId(client)),
             creditRegistry: tx.object(creditRegistryId(client)),
@@ -211,7 +207,7 @@ export function executeWithdrawalNative(client, tx, params) {
         package: queuePkg(client),
         arguments: {
             queue: tx.object(queueId(client)),
-            key: params.key,
+            key: toU64(params.key, "key"),
             request: request,
             vault: tx.object(custodyVaultId(client)),
             creditRegistry: tx.object(creditRegistryId(client)),

package/dist/src/constants.d.ts

@@ -9,7 +9,19 @@ export declare const DOUBLE_SCALE = 1000000000000000000n;
 export declare const SUI_DECIMALS = 9;
 /** WLP LP-token decimals. */
 export declare const WLP_DECIMALS = 6;
-/** Shared decimals for trading collateral / WLP backing assets (USDC, USDSUI). */
+/**
+ * Decimals for **collateral-typed** values only: the CREDIT/wxUSD internal
+ * balance and the USD-pegged trading collateral (USDC, USDSUI). All current
+ * collateral and the CREDIT coin are 6-dec, and the config JSON carries no
+ * credit decimal, so this constant is the single source for the CREDIT scale.
+ *
+ * Do NOT use it for custody **backing assets** — those carry a per-asset
+ * `decimal` in config (`NativeCustodyAsset.decimal`), threaded through
+ * `probeParkedBackingAssets` → `sumParkedBackingAsCreditRaw`. If a 9-dec
+ * backing asset ever lists, a path that assumed flat 6 for it would mis-scale
+ * its parked balance by 1000×; only a change to the CREDIT coin itself (or a
+ * non-6-dec collateral listing) would require touching this constant.
+ */
 export declare const COLLATERAL_DECIMALS = 6;
 /**
  * @deprecated Import the individual `SUI_DECIMALS` / `WLP_DECIMALS` /
@@ -23,6 +35,8 @@ export declare const TOKEN_DECIMALS: {
     readonly USDSUI: 6;
     readonly WLP: 6;
 };
+export declare const MS_PER_MINUTE: number;
+export declare const MS_PER_HOUR: number;
 export declare const MS_PER_YEAR: number;
 /**
  * Zero-address placeholder used as the sender in dry-run / simulate calls.

package/dist/src/constants.js

@@ -1,6 +1,6 @@
 // Shared, line-agnostic primitives (network id, scaling, decimals, time).
-// Perp-domain enums (permissions / order tags / action codes / fee rates) live
-// in `perp/constants.ts`; prediction has its own `prediction/constants.ts`.
+// Perp-domain enums (permissions / order tags / action codes) live in
+// `perp/constants.ts`; prediction has its own `prediction/constants.ts`.
 // ======== Scaling ========
 /** Basis-point denominator (10_000). Matches BP_SCALE in the Move contracts. */
 export const BPS_SCALE = 10000n;
@@ -13,7 +13,19 @@ export const DOUBLE_SCALE = 1000000000000000000n;
 export const SUI_DECIMALS = 9;
 /** WLP LP-token decimals. */
 export const WLP_DECIMALS = 6;
-/** Shared decimals for trading collateral / WLP backing assets (USDC, USDSUI). */
+/**
+ * Decimals for **collateral-typed** values only: the CREDIT/wxUSD internal
+ * balance and the USD-pegged trading collateral (USDC, USDSUI). All current
+ * collateral and the CREDIT coin are 6-dec, and the config JSON carries no
+ * credit decimal, so this constant is the single source for the CREDIT scale.
+ *
+ * Do NOT use it for custody **backing assets** — those carry a per-asset
+ * `decimal` in config (`NativeCustodyAsset.decimal`), threaded through
+ * `probeParkedBackingAssets` → `sumParkedBackingAsCreditRaw`. If a 9-dec
+ * backing asset ever lists, a path that assumed flat 6 for it would mis-scale
+ * its parked balance by 1000×; only a change to the CREDIT coin itself (or a
+ * non-6-dec collateral listing) would require touching this constant.
+ */
 export const COLLATERAL_DECIMALS = 6;
 /**
  * @deprecated Import the individual `SUI_DECIMALS` / `WLP_DECIMALS` /
@@ -28,6 +40,8 @@ export const TOKEN_DECIMALS = {
     WLP: WLP_DECIMALS,
 };
 // ======== Time ========
+export const MS_PER_MINUTE = 60 * 1000;
+export const MS_PER_HOUR = 60 * 60 * 1000;
 export const MS_PER_YEAR = 365 * 24 * 60 * 60 * 1000;
 // ======== Well-known addresses ========
 /**

package/dist/src/generated/waterx_rule/deps/bucket_v2_framework/float.d.ts

@@ -0,0 +1,8 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/** Module for floating points */
+import { MoveStruct } from '../../../utils/index.ts';
+export declare const Float: MoveStruct<{
+    value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u128">;
+}, "bucket_v2_framework::float::Float">;

package/dist/src/generated/waterx_rule/deps/bucket_v2_framework/float.js

@@ -0,0 +1,10 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/** Module for floating points */
+import { MoveStruct } from "../../../utils/index.js";
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = 'bucket_v2_framework::float';
+export const Float = new MoveStruct({ name: `${$moduleName}::Float`, fields: {
+        value: bcs.u128()
+    } });

package/dist/src/generated/waterx_rule/deps/sui/vec_map.d.ts

@@ -0,0 +1,36 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type BcsType } from '@mysten/sui/bcs';
+import { MoveStruct } from '../../../utils/index.ts';
+/** An entry in the map */
+export declare function Entry<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [
+    K,
+    V
+]): MoveStruct<{
+    key: K;
+    value: V;
+}, `0x2::vec_map::Entry<${K["name"]}, ${V["name"]}>`>;
+/**
+ * A map data structure backed by a vector. The map is guaranteed not to contain
+ * duplicate keys, but entries are _not_ sorted by key--entries are included in
+ * insertion order. All operations are O(N) in the size of the map--the intention
+ * of this data structure is only to provide the convenience of programming against
+ * a map API. Large maps should use handwritten parent/child relationships instead.
+ * Maps that need sorted iteration rather than insertion order iteration should
+ * also be handwritten.
+ */
+export declare function VecMap<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [
+    K,
+    V
+]): MoveStruct<{
+    contents: BcsType<{
+        key: K extends BcsType<infer U, any, string> ? U : never;
+        value: V extends BcsType<infer U, any, string> ? U : never;
+    }[], Iterable<{
+        key: K extends BcsType<any, infer U_1, string> ? U_1 : never;
+        value: V extends BcsType<any, infer U_1, string> ? U_1 : never;
+    }> & {
+        length: number;
+    }, string>;
+}, `0x2::vec_map::VecMap<${K["name"]}, ${V["name"]}>`>;

package/dist/src/generated/waterx_rule/deps/sui/vec_map.js

@@ -0,0 +1,27 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { bcs } from '@mysten/sui/bcs';
+import { MoveStruct } from "../../../utils/index.js";
+const $moduleName = '0x2::vec_map';
+/** An entry in the map */
+export function Entry(...typeParameters) {
+    return new MoveStruct({ name: `${$moduleName}::Entry<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
+            key: typeParameters[0],
+            value: typeParameters[1]
+        } });
+}
+/**
+ * A map data structure backed by a vector. The map is guaranteed not to contain
+ * duplicate keys, but entries are _not_ sorted by key--entries are included in
+ * insertion order. All operations are O(N) in the size of the map--the intention
+ * of this data structure is only to provide the convenience of programming against
+ * a map API. Large maps should use handwritten parent/child relationships instead.
+ * Maps that need sorted iteration rather than insertion order iteration should
+ * also be handwritten.
+ */
+export function VecMap(...typeParameters) {
+    return new MoveStruct({ name: `${$moduleName}::VecMap<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
+            contents: bcs.vector(Entry(typeParameters[0], typeParameters[1]))
+        } });
+}