@waterx/sdk 3.0.1 → 3.0.3

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

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PredictClient = void 0;
+const base_client_ts_1 = require("../base-client.js");
+const config_ts_1 = require("./config.js");
+class PredictClient extends base_client_ts_1.BaseLineClient {
+    /** Default settlement alias for prediction registry lookups. */
+    settlement;
+    constructor(network, config, opts = {}) {
+        super(network, config, opts);
+        this.settlement = opts.settlement ?? "USD";
+    }
+    static testnet(params = {}) {
+        return PredictClient.create("TESTNET", params);
+    }
+    static mainnet(params = {}) {
+        return PredictClient.create("MAINNET", params);
+    }
+    /**
+     * Async factory: fetches the deployment config for `network` and returns
+     * a ready-to-use client. Pass `opts.cache=true` to memoize the JSON.
+     */
+    static async create(network = "TESTNET", opts = {}) {
+        const config = await (0, config_ts_1.loadConfig)(network, opts);
+        return new PredictClient(network, config, {
+            grpcUrl: opts.grpcUrl,
+            settlement: opts.settlement,
+        });
+    }
+    /**
+     * Simulate with rate-limit retry — the prediction line hammers the public
+     * testnet RPC harder (batch claims / dual-path reads), so it backs off on
+     * `RESOURCE_EXHAUSTED` where the base client does not.
+     */
+    async simulate(tx) {
+        return withRpcRetry(() => super.simulate(tx));
+    }
+    // ========================================================
+    // Config-schema lookups (prediction-specific)
+    // ========================================================
+    packageId() {
+        return this.config.packages.waterx_prediction.published_at;
+    }
+    bucketFrameworkPackageId() {
+        return this.config.packages.bucket_framework.published_at;
+    }
+    waterxAccountPackageId() {
+        return this.config.packages.waterx_account.published_at;
+    }
+    globalConfigId() {
+        return this.config.packages.waterx_prediction.global_config;
+    }
+    marketRegistry(settlement = this.settlement) {
+        return requireConfigValue(this.config.packages.waterx_prediction.market_registries, settlement, `packages.waterx_prediction.market_registries.${settlement}`);
+    }
+    accountRegistry() {
+        return this.config.packages.waterx_account.account_registry;
+    }
+    settlementCoinType(settlement = this.settlement) {
+        return requireConfigValue(this.config.packages.waterx_prediction.settlement_coin_types, settlement, `packages.waterx_prediction.settlement_coin_types.${settlement}`);
+    }
+    predictionAdminCap() {
+        return requireConfigValue(this.config.packages.waterx_prediction, "admin_cap", "packages.waterx_prediction.admin_cap");
+    }
+    waterxAccountAdminCap() {
+        return requireConfigValue(this.config.packages.waterx_account, "admin_cap", "packages.waterx_account.admin_cap");
+    }
+    waterxPredictionGiftPackageId() {
+        return requireConfigValue(this.config.packages.waterx_prediction_gift, "published_at", "packages.waterx_prediction_gift.published_at");
+    }
+    claimableLinkConfigId() {
+        return requireConfigValue(this.config.packages.waterx_prediction_gift, "claimable_link_config", "packages.waterx_prediction_gift.claimable_link_config");
+    }
+    waterxReferralPackageId() {
+        return requireConfigValue(this.config.packages.waterx_referral, "published_at", "packages.waterx_referral.published_at");
+    }
+    referralTableId() {
+        return requireConfigValue(this.config.packages.waterx_referral, "referral_table", "packages.waterx_referral.referral_table");
+    }
+}
+exports.PredictClient = PredictClient;
+function requireConfigValue(map, key, path) {
+    const value = map?.[key];
+    if (typeof value !== "string" || value.length === 0) {
+        throw new Error(`waterx-config missing ${path}`);
+    }
+    return value;
+}
+/**
+ * Retry a grpc call on transient `RESOURCE_EXHAUSTED` (HTTP 429) responses from the public
+ * testnet RPC. Uses exponential backoff with jitter; bails on the first non-rate-limit error.
+ */
+async function withRpcRetry(fn, maxAttempts = 4) {
+    let lastErr;
+    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastErr = err;
+            const code = err?.code;
+            const msg = err instanceof Error ? err.message : String(err);
+            const isRateLimit = code === "RESOURCE_EXHAUSTED" || /too many requests|rate.?limit/i.test(msg);
+            if (!isRateLimit || attempt === maxAttempts - 1)
+                throw err;
+            const baseMs = 400 * 2 ** attempt; // 400, 800, 1600, ...
+            const jitter = Math.floor(Math.random() * 200);
+            await new Promise((r) => setTimeout(r, baseMs + jitter));
+        }
+    }
+    throw lastErr;
+}

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

@@ -0,0 +1,74 @@
+/**
+ * WaterX prediction deployment config loader.
+ *
+ * Mirrors the canonical `waterx-config` JSON for the packages used by this SDK
+ * and fetches it from GitHub raw by default.
+ */
+import type { Network } from "./constants.ts";
+export interface WaterxConfigPackageBase {
+    published_at: string;
+    original_id?: string;
+    version?: number;
+    upgrade_capability?: string;
+}
+export interface WaterxAccountPackage extends WaterxConfigPackageBase {
+    admin_cap?: string;
+    account_registry: string;
+}
+export interface WaterxPredictionPackage extends WaterxConfigPackageBase {
+    admin_cap?: string;
+    global_config: string;
+    market_registries: Record<string, string>;
+    settlement_coin_types?: Record<string, string>;
+}
+export interface WaterxPredictionGiftPackage extends WaterxConfigPackageBase {
+    admin_cap?: string;
+    /** `ClaimableLinkConfig` shared object id. */
+    claimable_link_config: string;
+}
+export interface WaterxReferralPackage extends WaterxConfigPackageBase {
+    admin_cap?: string;
+    /** `ReferralTable` shared object id. */
+    referral_table: string;
+}
+export interface WaterxPredictionConfigPackages {
+    bucket_framework: WaterxConfigPackageBase;
+    waterx_account: WaterxAccountPackage;
+    waterx_prediction: WaterxPredictionPackage;
+    waterx_prediction_gift?: WaterxPredictionGiftPackage;
+    waterx_referral?: WaterxReferralPackage;
+    [name: string]: unknown;
+}
+export interface WaterxPredictionConfig {
+    network?: string;
+    chain_id?: string | number | null;
+    grpcUrl?: string;
+    packages: WaterxPredictionConfigPackages;
+}
+export interface LoadConfigOptions {
+    /**
+     * Override the default waterx-config raw JSON URL. Use this to point at a
+     * local mirror during development. Takes precedence over {@link configRef}.
+     */
+    configUrl?: string;
+    /**
+     * Pin the canonical config to a specific git ref — a commit SHA, branch, or
+     * tag — instead of the default `main` branch. Resolves to
+     * `https://raw.githubusercontent.com/WaterXProtocol/waterx-config/<ref>/<network>.json`.
+     * Ignored when {@link configUrl} is set.
+     */
+    configRef?: string;
+    /** Reuse a previously fetched config in memory. Default: false. */
+    cache?: boolean;
+    /** Optional fetch implementation for tests or runtimes without global fetch. */
+    fetchImpl?: typeof fetch;
+    /** Request timeout in ms. Default: 10_000. */
+    timeoutMs?: number;
+}
+/**
+ * Build the canonical config URL for `network`, optionally pinned to a
+ * specific git `ref` (commit SHA, branch, or tag). Defaults to `main`.
+ */
+export declare function defaultConfigUrl(network: Network, ref?: string): string;
+export declare function clearConfigCache(): void;
+export declare function loadConfig(network: Network, opts?: LoadConfigOptions): Promise<WaterxPredictionConfig>;

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

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * WaterX prediction deployment config loader.
+ *
+ * Mirrors the canonical `waterx-config` JSON for the packages used by this SDK
+ * and fetches it from GitHub raw by default.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultConfigUrl = defaultConfigUrl;
+exports.clearConfigCache = clearConfigCache;
+exports.loadConfig = loadConfig;
+const CONFIG_REPO_RAW_BASE = "https://raw.githubusercontent.com/WaterXProtocol/waterx-config";
+/** Default git ref for the canonical config when none is pinned. */
+const DEFAULT_CONFIG_REF = "main";
+/**
+ * Build the canonical config URL for `network`, optionally pinned to a
+ * specific git `ref` (commit SHA, branch, or tag). Defaults to `main`.
+ */
+function defaultConfigUrl(network, ref = DEFAULT_CONFIG_REF) {
+    return `${CONFIG_REPO_RAW_BASE}/${ref}/${network.toLowerCase()}.json`;
+}
+const configCache = new Map();
+function clearConfigCache() {
+    configCache.clear();
+}
+async function loadConfig(network, opts = {}) {
+    const url = opts.configUrl ?? defaultConfigUrl(network, opts.configRef);
+    if (opts.cache && configCache.has(url)) {
+        return configCache.get(url);
+    }
+    const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+    if (!fetchImpl) {
+        throw new Error("loadConfig: no global fetch available; pass opts.fetchImpl");
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), opts.timeoutMs ?? 10_000);
+    let response;
+    try {
+        response = await fetchImpl(url, { signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    if (!response.ok) {
+        throw new Error(`loadConfig: HTTP ${response.status} fetching ${url}`);
+    }
+    const raw = (await response.json());
+    validateConfig(raw, network, url);
+    if (opts.cache) {
+        configCache.set(url, raw);
+    }
+    return raw;
+}
+function validateConfig(cfg, expected, url) {
+    if (cfg.network !== undefined && cfg.network.toUpperCase() !== expected) {
+        throw new Error(`loadConfig: config at ${url} declares network=${cfg.network} but caller asked for ${expected}`);
+    }
+    if (!isRecord(cfg.packages)) {
+        throw new Error(`loadConfig: config at ${url} has no packages object`);
+    }
+    const packages = cfg.packages;
+    requirePublishedPackage(packages.bucket_framework, "bucket_framework", url);
+    const account = requirePublishedPackage(packages.waterx_account, "waterx_account", url);
+    const prediction = requirePublishedPackage(packages.waterx_prediction, "waterx_prediction", url);
+    if (!isNonEmptyString(account.account_registry)) {
+        throw new Error(`loadConfig: config at ${url} missing packages.waterx_account.account_registry`);
+    }
+    if (!isNonEmptyString(prediction.global_config)) {
+        throw new Error(`loadConfig: config at ${url} missing packages.waterx_prediction.global_config`);
+    }
+    if (!isRecord(prediction.market_registries)) {
+        throw new Error(`loadConfig: config at ${url} missing packages.waterx_prediction.market_registries`);
+    }
+}
+function requirePublishedPackage(value, name, url) {
+    if (!isRecord(value) || !isNonEmptyString(value.published_at)) {
+        throw new Error(`loadConfig: config at ${url} missing packages.${name}.published_at`);
+    }
+    return value;
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.length > 0;
+}

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

@@ -0,0 +1,44 @@
+export type Network = "MAINNET" | "TESTNET";
+export declare const CLOCK_OBJECT_ID = "0x6";
+export declare const PREDICTION_PERM_PLACE_ORDER: number;
+export declare const PREDICTION_PERM_CANCEL_ORDER: number;
+export declare const PREDICTION_PERM_CLAIM: number;
+export declare const PREDICTION_PERM_REQUEST_CLOSE: number;
+/** Default chunk size for `buildBatchForceClaimTransactions` (1 request + N claims; Sui max ~1024 commands). */
+export declare const DEFAULT_FORCE_CLAIM_CHUNK_SIZE = 1000;
+export declare const PREDICTION_PERM_ALL: number;
+export declare const ACCOUNT_PERM_WITHDRAW: number;
+export declare const ACCOUNT_PERM_MANAGE_DELEGATES: number;
+export declare const ACCOUNT_PERM_RECEIVE: number;
+export declare const ACCOUNT_PERM_ALL = 4294967295;
+/**
+ * Gift KDF / signed-message constants. Mirror `waterx_prediction_gift::claimable_link`.
+ * Stable across package upgrades — outstanding URLs must keep working.
+ */
+export declare const GIFT_KDF_DOMAIN: Uint8Array<ArrayBuffer>;
+export declare const GIFT_DOMAIN_CLAIM: Uint8Array<ArrayBuffer>;
+export declare const GIFT_URL_SEED_BYTES = 16;
+export declare const GIFT_PUBKEY_LEN = 32;
+export declare const GIFT_SIG_LEN = 64;
+export declare const GIFT_CONTROLLER_DELEGATE_ALIAS = "waterx_gift_controller";
+export declare const GIFT_AUTO_MAIN_ACCOUNT_ALIAS = "main";
+export declare const GIFT_MAX_SHARES_PER_GIFT = 500;
+export declare const PREDICTION_ERROR_CODES: {
+    readonly EBadStatus: 1;
+    readonly EMarketNotResolved: 3;
+    readonly EAlreadyResolved: 4;
+    readonly EBadPriceCap: 5;
+    readonly EFillExceedsMax: 6;
+    readonly EFillBelowMin: 7;
+    readonly EBadExpiry: 8;
+    readonly EBadPayment: 9;
+    readonly EMarketPaused: 10;
+    readonly EBelowMinReserve: 11;
+    readonly EMarketAlreadyResolved: 12;
+    readonly ECloseProceedsBelowMin: 13;
+    readonly EUnauthorized: 14;
+    readonly ENotAccountPosition: 16;
+    readonly EOrderInCooldown: 17;
+    readonly EOrderExpired: 18;
+    readonly EOrderNotExpired: 19;
+};

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PREDICTION_ERROR_CODES = exports.GIFT_MAX_SHARES_PER_GIFT = exports.GIFT_AUTO_MAIN_ACCOUNT_ALIAS = exports.GIFT_CONTROLLER_DELEGATE_ALIAS = exports.GIFT_SIG_LEN = exports.GIFT_PUBKEY_LEN = exports.GIFT_URL_SEED_BYTES = exports.GIFT_DOMAIN_CLAIM = exports.GIFT_KDF_DOMAIN = exports.ACCOUNT_PERM_ALL = exports.ACCOUNT_PERM_RECEIVE = exports.ACCOUNT_PERM_MANAGE_DELEGATES = exports.ACCOUNT_PERM_WITHDRAW = exports.PREDICTION_PERM_ALL = exports.DEFAULT_FORCE_CLAIM_CHUNK_SIZE = exports.PREDICTION_PERM_REQUEST_CLOSE = exports.PREDICTION_PERM_CLAIM = exports.PREDICTION_PERM_CANCEL_ORDER = exports.PREDICTION_PERM_PLACE_ORDER = exports.CLOCK_OBJECT_ID = void 0;
+exports.CLOCK_OBJECT_ID = "0x6";
+exports.PREDICTION_PERM_PLACE_ORDER = 1 << 0;
+exports.PREDICTION_PERM_CANCEL_ORDER = 1 << 1;
+exports.PREDICTION_PERM_CLAIM = 1 << 2;
+exports.PREDICTION_PERM_REQUEST_CLOSE = 1 << 3;
+/** Default chunk size for `buildBatchForceClaimTransactions` (1 request + N claims; Sui max ~1024 commands). */
+exports.DEFAULT_FORCE_CLAIM_CHUNK_SIZE = 1000;
+exports.PREDICTION_PERM_ALL = exports.PREDICTION_PERM_PLACE_ORDER |
+    exports.PREDICTION_PERM_CANCEL_ORDER |
+    exports.PREDICTION_PERM_CLAIM |
+    exports.PREDICTION_PERM_REQUEST_CLOSE;
+exports.ACCOUNT_PERM_WITHDRAW = 1 << 0;
+exports.ACCOUNT_PERM_MANAGE_DELEGATES = 1 << 1;
+exports.ACCOUNT_PERM_RECEIVE = 1 << 2;
+exports.ACCOUNT_PERM_ALL = 0xffffffff;
+/**
+ * Gift KDF / signed-message constants. Mirror `waterx_prediction_gift::claimable_link`.
+ * Stable across package upgrades — outstanding URLs must keep working.
+ */
+exports.GIFT_KDF_DOMAIN = new TextEncoder().encode("waterx_prediction_gift/kdf");
+exports.GIFT_DOMAIN_CLAIM = new TextEncoder().encode("waterx_prediction_gift/claim");
+exports.GIFT_URL_SEED_BYTES = 16;
+exports.GIFT_PUBKEY_LEN = 32;
+exports.GIFT_SIG_LEN = 64;
+exports.GIFT_CONTROLLER_DELEGATE_ALIAS = "waterx_gift_controller";
+exports.GIFT_AUTO_MAIN_ACCOUNT_ALIAS = "main";
+exports.GIFT_MAX_SHARES_PER_GIFT = 500;
+exports.PREDICTION_ERROR_CODES = {
+    EBadStatus: 1,
+    EMarketNotResolved: 3,
+    EAlreadyResolved: 4,
+    EBadPriceCap: 5,
+    EFillExceedsMax: 6,
+    EFillBelowMin: 7,
+    EBadExpiry: 8,
+    EBadPayment: 9,
+    EMarketPaused: 10,
+    EBelowMinReserve: 11,
+    EMarketAlreadyResolved: 12,
+    ECloseProceedsBelowMin: 13,
+    EUnauthorized: 14,
+    ENotAccountPosition: 16,
+    EOrderInCooldown: 17,
+    EOrderExpired: 18,
+    EOrderNotExpired: 19,
+};

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

@@ -0,0 +1,82 @@
+import type { PredictClient } from "./client.ts";
+import type { AccountDataView, CursorView, MarketExposure, MarketIdInput, MarketView, OrderView, PositionView, RegistryView } from "./types.ts";
+export declare function extractReturnBytes(result: any, commandIndex?: number, returnIndex?: number): Uint8Array;
+export interface ViewBaseParams {
+    packageId?: string;
+    marketRegistry?: string;
+    accountRegistry?: string;
+    settlementCoinType?: string;
+}
+export declare function getRegistry(client: PredictClient, params?: ViewBaseParams): Promise<RegistryView>;
+export declare function getOrder(client: PredictClient, params: ViewBaseParams & {
+    orderId: bigint | number | string;
+}): Promise<OrderView>;
+export declare function getPosition(client: PredictClient, params: ViewBaseParams & {
+    positionId: bigint | number | string;
+}): Promise<PositionView>;
+export declare function getMarketById(client: PredictClient, params: ViewBaseParams & {
+    marketId: MarketIdInput;
+}): Promise<MarketView>;
+export declare function getMarketByKey(client: PredictClient, params: ViewBaseParams & {
+    marketKey: bigint | number | string;
+}): Promise<MarketView>;
+export declare function getMarketExposure(client: PredictClient, params: ViewBaseParams & {
+    marketId: MarketIdInput;
+}): Promise<MarketExposure>;
+export declare function getMarketExposureByKey(client: PredictClient, params: ViewBaseParams & {
+    marketKey: bigint | number | string;
+}): Promise<MarketExposure>;
+export declare function getOrderCursor(client: PredictClient, params?: ViewBaseParams): Promise<CursorView>;
+export declare function getPositionCursor(client: PredictClient, params?: ViewBaseParams): Promise<CursorView>;
+export declare function getUnresolvedMarketCursor(client: PredictClient, params?: ViewBaseParams): Promise<CursorView>;
+export declare function getResolvedMarketCursor(client: PredictClient, params?: ViewBaseParams): Promise<CursorView>;
+export interface GetAccountIdsParams {
+    /** Wallet address that owns sub-accounts in the registry. */
+    owner: string;
+    accountRegistry?: string;
+    /** `waterx_account` package id (defaults to `client.waterxAccountPackageId()`). */
+    accountPackageId?: string;
+}
+/**
+ * Registry account ids (`0x2::object::ID`) for an owner via `waterx_account::account::account_ids`.
+ * Use these ids with `getAccountData`, `deposit`, and `placeOrder` — not Suiscan "Account" object addresses.
+ */
+export declare function getAccountIds(client: PredictClient, params: GetAccountIdsParams): Promise<string[]>;
+export declare function getAccountData(client: PredictClient, params: ViewBaseParams & {
+    accountId: string;
+}): Promise<AccountDataView>;
+export declare function getAccountOrderIds(client: PredictClient, params: ViewBaseParams & {
+    accountId: string;
+    marketKey: bigint | number | string;
+}): Promise<bigint[]>;
+export declare function getAccountPositionIds(client: PredictClient, params: ViewBaseParams & {
+    accountId: string;
+    marketKey: bigint | number | string;
+}): Promise<bigint[]>;
+export declare function getAccountOrderIdsByMarketId(client: PredictClient, params: ViewBaseParams & {
+    accountId: string;
+    marketId: MarketIdInput;
+}): Promise<bigint[]>;
+export declare function getAccountPositionIdsByMarketId(client: PredictClient, params: ViewBaseParams & {
+    accountId: string;
+    marketId: MarketIdInput;
+}): Promise<bigint[]>;
+export declare function isKeeper(client: PredictClient, params: {
+    packageId?: string;
+    globalConfig?: string;
+    keeper: string;
+}): Promise<boolean>;
+export declare function getKeeperAddresses(client: PredictClient, params?: {
+    packageId?: string;
+    globalConfig?: string;
+}): Promise<string[]>;
+export declare function getAllowedVersions(client: PredictClient, params?: {
+    packageId?: string;
+    globalConfig?: string;
+}): Promise<number[]>;
+export declare function isPredictionProtocolAssetAllowed(client: PredictClient, params?: {
+    accountPackageId?: string;
+    accountRegistry?: string;
+    predictionPackageId?: string;
+    coinType?: string;
+}): Promise<boolean>;