@waterx/sdk 2.1.0 → 2.3.1-dev.0

package/dist/src/prediction/client.d.ts

@@ -0,0 +1,75 @@
+import type { SuiClientTypes } from "@mysten/sui/client";
+import type { Signer } from "@mysten/sui/cryptography";
+import { SuiGrpcClient } from "@mysten/sui/grpc";
+import type { Transaction } from "@mysten/sui/transactions";
+import { type LoadConfigOptions, type WaterxPredictionConfig } from "./config.ts";
+import type { Network } from "./constants.ts";
+export interface CreateClientOptions extends LoadConfigOptions {
+    grpcUrl?: string;
+    /** Settlement alias in `packages.waterx_prediction.*` maps. Default: "USD". */
+    settlement?: string;
+}
+export declare class PredictClient {
+    /** gRPC client - all RPC including `simulateTransaction`. */
+    grpcClient: SuiGrpcClient;
+    /** Network identifier in upper case (`MAINNET` / `TESTNET`). */
+    network: Network;
+    /** Parsed canonical `waterx-config` JSON. */
+    config: WaterxPredictionConfig;
+    /** Default settlement alias for prediction registry lookups. */
+    settlement: string;
+    constructor(network: Network, config: WaterxPredictionConfig, opts?: {
+        grpcUrl?: string;
+        settlement?: string;
+    });
+    static testnet(params?: CreateClientOptions): Promise<PredictClient>;
+    static mainnet(params?: CreateClientOptions): Promise<PredictClient>;
+    /**
+     * Async factory: fetches the deployment config for `network` and returns
+     * a ready-to-use client. Pass `opts.cache=true` to memoize the JSON.
+     */
+    static create(network?: Network, opts?: CreateClientOptions): Promise<PredictClient>;
+    getObject(objectId: string): Promise<SuiClientTypes.GetObjectResponse<{}>>;
+    getObjects(objectIds: string[]): Promise<SuiClientTypes.GetObjectsResponse<{}>>;
+    listOwnedObjects(owner: string): Promise<SuiClientTypes.ListOwnedObjectsResponse<{}>>;
+    listCoins(params: {
+        owner: string;
+        coinType?: string;
+    }): Promise<SuiClientTypes.ListCoinsResponse>;
+    getBalance(params: {
+        owner: string;
+        coinType?: string;
+    }): Promise<SuiClientTypes.GetBalanceResponse>;
+    listDynamicFields(parentId: string): ReturnType<SuiGrpcClient["listDynamicFields"]>;
+    getDynamicField(parentId: string, name: {
+        type: string;
+        bcs: Uint8Array;
+    }): Promise<SuiClientTypes.GetDynamicFieldResponse>;
+    waitForTransaction(digest: string): Promise<SuiClientTypes.TransactionResult<{}>>;
+    simulate(tx: Transaction): Promise<SuiClientTypes.SimulateTransactionResult<{
+        commandResults: true;
+    }>>;
+    signAndExecuteTransaction<Include extends SuiClientTypes.TransactionInclude = object>(params: {
+        signer: {
+            toSuiAddress: () => string;
+        } & Signer;
+        transaction: Transaction | Uint8Array;
+        additionalSignatures?: string[];
+        include?: Include & SuiClientTypes.TransactionInclude;
+    }): Promise<SuiClientTypes.TransactionResult<Include & SuiClientTypes.TransactionInclude>>;
+    /** All package IDs (`published_at`) keyed by package name. */
+    packageIds(): Record<string, string>;
+    packageId(): string;
+    bucketFrameworkPackageId(): string;
+    waterxAccountPackageId(): string;
+    globalConfigId(): string;
+    marketRegistry(settlement?: string): string;
+    accountRegistry(): string;
+    settlementCoinType(settlement?: string): string;
+    predictionAdminCap(): string;
+    waterxAccountAdminCap(): string;
+    waterxPredictionGiftPackageId(): string;
+    claimableLinkConfigId(): string;
+    waterxReferralPackageId(): string;
+    referralTableId(): string;
+}

package/dist/src/prediction/client.js

@@ -0,0 +1,164 @@
+import { SuiGrpcClient } from "@mysten/sui/grpc";
+import { loadConfig, } from "./config.js";
+const GRPC_URLS = {
+    MAINNET: "https://fullnode.mainnet.sui.io:443",
+    TESTNET: "https://fullnode.testnet.sui.io:443",
+};
+export class PredictClient {
+    /** gRPC client - all RPC including `simulateTransaction`. */
+    grpcClient;
+    /** Network identifier in upper case (`MAINNET` / `TESTNET`). */
+    network;
+    /** Parsed canonical `waterx-config` JSON. */
+    config;
+    /** Default settlement alias for prediction registry lookups. */
+    settlement;
+    constructor(network, config, opts = {}) {
+        this.network = network;
+        this.config = config;
+        this.settlement = opts.settlement ?? "USD";
+        const baseUrl = opts.grpcUrl ?? config.grpcUrl ?? GRPC_URLS[network];
+        this.grpcClient = new SuiGrpcClient({
+            baseUrl,
+            network: network.toLowerCase(),
+        });
+    }
+    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 loadConfig(network, opts);
+        return new PredictClient(network, config, {
+            grpcUrl: opts.grpcUrl,
+            settlement: opts.settlement,
+        });
+    }
+    getObject(objectId) {
+        return this.grpcClient.getObject({ objectId });
+    }
+    getObjects(objectIds) {
+        return this.grpcClient.getObjects({ objectIds });
+    }
+    listOwnedObjects(owner) {
+        return this.grpcClient.listOwnedObjects({ owner });
+    }
+    listCoins(params) {
+        return this.grpcClient.listCoins(params);
+    }
+    getBalance(params) {
+        return this.grpcClient.getBalance(params);
+    }
+    listDynamicFields(parentId) {
+        return this.grpcClient.listDynamicFields({ parentId });
+    }
+    getDynamicField(parentId, name) {
+        return this.grpcClient.getDynamicField({ parentId, name });
+    }
+    waitForTransaction(digest) {
+        return this.grpcClient.waitForTransaction({ digest });
+    }
+    async simulate(tx) {
+        return withRpcRetry(() => this.grpcClient.simulateTransaction({
+            transaction: tx,
+            include: { commandResults: true },
+        }));
+    }
+    async signAndExecuteTransaction(params) {
+        return this.grpcClient.signAndExecuteTransaction(params);
+    }
+    // ========================================================
+    // Shorthand accessors (canonical-schema lookups)
+    // ========================================================
+    /** All package IDs (`published_at`) keyed by package name. */
+    packageIds() {
+        const out = {};
+        for (const [name, pkg] of Object.entries(this.config.packages)) {
+            if (isPublishedPackage(pkg))
+                out[name] = pkg.published_at;
+        }
+        return out;
+    }
+    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");
+    }
+}
+function isPublishedPackage(value) {
+    return (!!value &&
+        typeof value === "object" &&
+        "published_at" in value &&
+        typeof value.published_at === "string");
+}
+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/src/prediction/config.d.ts

@@ -0,0 +1,60 @@
+/**
+ * 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. */
+    configUrl?: 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;
+}
+export declare function defaultConfigUrl(network: Network): string;
+export declare function clearConfigCache(): void;
+export declare function loadConfig(network: Network, opts?: LoadConfigOptions): Promise<WaterxPredictionConfig>;

package/dist/src/prediction/config.js

@@ -0,0 +1,75 @@
+/**
+ * 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.
+ */
+const DEFAULT_CONFIG_URL_BASE = "https://raw.githubusercontent.com/WaterXProtocol/waterx-config/main";
+export function defaultConfigUrl(network) {
+    return `${DEFAULT_CONFIG_URL_BASE}/${network.toLowerCase()}.json`;
+}
+const configCache = new Map();
+export function clearConfigCache() {
+    configCache.clear();
+}
+export async function loadConfig(network, opts = {}) {
+    const url = opts.configUrl ?? defaultConfigUrl(network);
+    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/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/src/prediction/constants.js

@@ -0,0 +1,46 @@
+export const CLOCK_OBJECT_ID = "0x6";
+export const PREDICTION_PERM_PLACE_ORDER = 1 << 0;
+export const PREDICTION_PERM_CANCEL_ORDER = 1 << 1;
+export const PREDICTION_PERM_CLAIM = 1 << 2;
+export const PREDICTION_PERM_REQUEST_CLOSE = 1 << 3;
+/** Default chunk size for `buildBatchForceClaimTransactions` (1 request + N claims; Sui max ~1024 commands). */
+export const DEFAULT_FORCE_CLAIM_CHUNK_SIZE = 1000;
+export const PREDICTION_PERM_ALL = PREDICTION_PERM_PLACE_ORDER |
+    PREDICTION_PERM_CANCEL_ORDER |
+    PREDICTION_PERM_CLAIM |
+    PREDICTION_PERM_REQUEST_CLOSE;
+export const ACCOUNT_PERM_WITHDRAW = 1 << 0;
+export const ACCOUNT_PERM_MANAGE_DELEGATES = 1 << 1;
+export const ACCOUNT_PERM_RECEIVE = 1 << 2;
+export const ACCOUNT_PERM_ALL = 0xffffffff;
+/**
+ * Gift KDF / signed-message constants. Mirror `waterx_prediction_gift::claimable_link`.
+ * Stable across package upgrades — outstanding URLs must keep working.
+ */
+export const GIFT_KDF_DOMAIN = new TextEncoder().encode("waterx_prediction_gift/kdf");
+export const GIFT_DOMAIN_CLAIM = new TextEncoder().encode("waterx_prediction_gift/claim");
+export const GIFT_URL_SEED_BYTES = 16;
+export const GIFT_PUBKEY_LEN = 32;
+export const GIFT_SIG_LEN = 64;
+export const GIFT_CONTROLLER_DELEGATE_ALIAS = "waterx_gift_controller";
+export const GIFT_AUTO_MAIN_ACCOUNT_ALIAS = "main";
+export const GIFT_MAX_SHARES_PER_GIFT = 500;
+export const 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/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>;