@waterx/predict-sdk 0.1.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 WaterX
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,67 @@
+# @waterx/predict-sdk
+
+TypeScript SDK for `waterx_prediction`, the WaterX prediction market broker on Sui.
+
+The package exposes:
+
+- `PredictClient` for Sui gRPC, simulation, and execution.
+- User PTB builders for `placeOrder`, `requestClose`, `claim`, and self-cancel paths.
+- Keeper PTB builders for fill/cancel/close/resolve/force-claim paths.
+- Admin PTB builders for registry setup, settlement funding, pause controls, and keeper management.
+- Generated Move wrappers in `src/generated` via `pnpm codegen`.
+- User-facing grouped exports under `src/user`.
+- Shared argument/BCS helpers under `src/utils`.
+- View helpers that read `waterx_prediction::view` via `simulateTransaction` and BCS parsing.
+
+```ts
+import { PredictClient, placeOrder } from "@waterx/predict-sdk";
+import { Transaction } from "@mysten/sui/transactions";
+
+const client = PredictClient.testnet();
+
+const tx = new Transaction();
+placeOrder(client, tx, {
+  accountId: "0x...",
+  maxSpend: 100_000_000n,
+  marketId: "0x...",
+  selection: "YES",
+  minShares: 50_000_000n,
+  priceCapBps: 7_000n,
+  expiryTs: 9_999_999_999_999n,
+});
+```
+
+Testnet package, shared object, registry, and settlement coin defaults are wired from the WaterX config snapshot:
+[`WaterXProtocol/waterx-config`](https://github.com/WaterXProtocol/waterx-config).
+You can still override any ID when testing a new deployment:
+
+```ts
+const client = PredictClient.testnet({
+  packageId: "0x...",
+  globalConfig: "0x...",
+  marketRegistry: "0x...",
+  accountRegistry: "0x...",
+  settlementCoinType: "0x...::coin::COIN",
+});
+```
+
+## Input validation
+
+- PTB helpers use strict literals for `Selection` / `Outcome` (`"YES"`, `"NO"`, `"INVALID"`). On-chain view decoding accepts Move enum casing (for example `"Yes"`).
+- `normalizeMarketId()` is for PTB `vector<u8>` arguments. Strings starting with `0x` are parsed as hex; other strings are UTF-8. View decoding expects `Uint8Array` or `number[]` for `market_id`, not strings.
+- `toBigInt()` rejects empty strings, non-integers, negatives, and values above `u64::MAX`.
+
+## Development
+
+```bash
+pnpm codegen
+pnpm typecheck
+pnpm build
+pnpm test:unit
+```
+
+`pnpm codegen` regenerates `src/generated` from:
+
+- `../waterx-contract/waterx_prediction`
+- `../waterx-contract/waterx_account`
+- `../waterx-contract/bucket_framework`

package/dist/src/account.d.ts

@@ -0,0 +1,64 @@
+import { Transaction, type TransactionArgument } from "@mysten/sui/transactions";
+import type { PredictClient } from "./client.ts";
+import type { AccountIdentityParams, CoinRef, IdArgument, ObjectArgument } from "./types.ts";
+export interface AccountBaseParams {
+    accountPackageId?: string;
+    accountRegistry?: string;
+}
+export interface CreateAccountParams extends AccountBaseParams, AccountIdentityParams {
+    alias: string;
+}
+export declare function createAccount(client: PredictClient, tx: Transaction, params: CreateAccountParams): TransactionArgument;
+export interface TransferCoinToAccountParams extends AccountBaseParams {
+    accountId: IdArgument;
+    coin: ObjectArgument;
+    coinType?: string;
+}
+export declare function transferCoinToAccount(client: PredictClient, tx: Transaction, params: TransferCoinToAccountParams): Transaction;
+export interface RequestDepositParams extends AccountBaseParams {
+    accountId: IdArgument;
+    coin: ObjectArgument;
+    coinType?: string;
+    extraData?: Uint8Array | number[];
+}
+export declare function requestDeposit(client: PredictClient, tx: Transaction, params: RequestDepositParams): TransactionArgument;
+export interface RequestDepositFromReceivingsParams extends AccountBaseParams {
+    accountId: IdArgument;
+    coins: CoinRef[];
+    coinType?: string;
+    extraData?: Uint8Array | number[];
+}
+export declare function requestDepositFromReceivings(client: PredictClient, tx: Transaction, params: RequestDepositFromReceivingsParams): TransactionArgument;
+export interface RequestWithdrawParams extends AccountBaseParams, AccountIdentityParams {
+    accountId: IdArgument;
+    amount: bigint | number | string;
+    recipient: string;
+    coinType?: string;
+    extraData?: Uint8Array | number[];
+}
+export declare function requestWithdraw(client: PredictClient, tx: Transaction, params: RequestWithdrawParams): TransactionArgument;
+export interface AddDelegateParams extends AccountBaseParams, AccountIdentityParams {
+    accountId: IdArgument;
+    delegate: string;
+    alias: string;
+    permissions: number;
+    expiresAtMs?: bigint | number | string | null;
+}
+export declare function addDelegate(client: PredictClient, tx: Transaction, params: AddDelegateParams): Transaction;
+export interface RemoveDelegateParams extends AccountBaseParams, AccountIdentityParams {
+    accountId: IdArgument;
+    delegate: string;
+}
+export declare function removeDelegate(client: PredictClient, tx: Transaction, params: RemoveDelegateParams): Transaction;
+export interface SetDelegatePredictionPermissionParams extends AccountBaseParams, AccountIdentityParams {
+    accountId: IdArgument;
+    delegate: string;
+    permissions: number;
+    predictionPackageId?: string;
+}
+export declare function setDelegatePredictionPermission(client: PredictClient, tx: Transaction, params: SetDelegatePredictionPermissionParams): Transaction;
+export interface WhitelistPredictionProtocolParams extends AccountBaseParams {
+    adminCap: ObjectArgument;
+    predictionPackageId?: string;
+}
+export declare function whitelistPredictionProtocol(client: PredictClient, tx: Transaction, params: WhitelistPredictionProtocolParams): Transaction;

package/dist/src/account.js

@@ -0,0 +1,134 @@
+import { clockArg, createAccountRequest, idArg, objectArg, receivingCoinArg, resolveAccountRegistry, resolvePackageId, toBigInt, } from "./utils.js";
+function accountPackage(client, packageId) {
+    return packageId ?? client.config.waterxAccountPackageId;
+}
+export function createAccount(client, tx, params) {
+    const senderRequest = createAccountRequest(client, tx, params);
+    const [accountId] = tx.moveCall({
+        target: `${accountPackage(client, params.accountPackageId)}::account::create_account`,
+        arguments: [
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            senderRequest,
+            tx.pure.string(params.alias),
+        ],
+    });
+    return accountId;
+}
+export function transferCoinToAccount(client, tx, params) {
+    tx.moveCall({
+        target: `${accountPackage(client, params.accountPackageId)}::account::transfer_coin`,
+        typeArguments: [params.coinType ?? client.config.settlementCoinType],
+        arguments: [
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            idArg(tx, params.accountId),
+            objectArg(tx, params.coin),
+        ],
+    });
+    return tx;
+}
+export function requestDeposit(client, tx, params) {
+    const [request] = tx.moveCall({
+        target: `${accountPackage(client, params.accountPackageId)}::account::request_deposit`,
+        typeArguments: [params.coinType ?? client.config.settlementCoinType],
+        arguments: [
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            idArg(tx, params.accountId),
+            objectArg(tx, params.coin),
+            tx.pure.vector("u8", Array.from(params.extraData ?? [])),
+        ],
+    });
+    return request;
+}
+export function requestDepositFromReceivings(client, tx, params) {
+    const coinType = params.coinType ?? client.config.settlementCoinType;
+    const receivings = params.coins.map((coin) => receivingCoinArg(tx, coin));
+    const [request] = tx.moveCall({
+        target: `${accountPackage(client, params.accountPackageId)}::account::request_deposit_from_receivings`,
+        typeArguments: [coinType],
+        arguments: [
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            idArg(tx, params.accountId),
+            tx.makeMoveVec({
+                type: `0x2::transfer::Receiving<0x2::coin::Coin<${coinType}>>`,
+                elements: receivings,
+            }),
+            tx.pure.vector("u8", Array.from(params.extraData ?? [])),
+        ],
+    });
+    return request;
+}
+export function requestWithdraw(client, tx, params) {
+    const senderRequest = createAccountRequest(client, tx, params);
+    const [request] = tx.moveCall({
+        target: `${accountPackage(client, params.accountPackageId)}::account::request_withdraw`,
+        typeArguments: [params.coinType ?? client.config.settlementCoinType],
+        arguments: [
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            senderRequest,
+            idArg(tx, params.accountId),
+            tx.pure.u64(toBigInt(params.amount)),
+            tx.pure.address(params.recipient),
+            tx.pure.vector("u8", Array.from(params.extraData ?? [])),
+            clockArg(tx),
+        ],
+    });
+    return request;
+}
+export function addDelegate(client, tx, params) {
+    const senderRequest = createAccountRequest(client, tx, params);
+    tx.moveCall({
+        target: `${accountPackage(client, params.accountPackageId)}::account::add_delegate`,
+        arguments: [
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            senderRequest,
+            idArg(tx, params.accountId),
+            tx.pure.address(params.delegate),
+            tx.pure.string(params.alias),
+            tx.pure.u32(params.permissions),
+            tx.pure.option("u64", params.expiresAtMs == null ? null : toBigInt(params.expiresAtMs)),
+            clockArg(tx),
+        ],
+    });
+    return tx;
+}
+export function removeDelegate(client, tx, params) {
+    const senderRequest = createAccountRequest(client, tx, params);
+    tx.moveCall({
+        target: `${accountPackage(client, params.accountPackageId)}::account::remove_delegate`,
+        arguments: [
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            senderRequest,
+            idArg(tx, params.accountId),
+            tx.pure.address(params.delegate),
+            clockArg(tx),
+        ],
+    });
+    return tx;
+}
+export function setDelegatePredictionPermission(client, tx, params) {
+    const senderRequest = createAccountRequest(client, tx, params);
+    tx.moveCall({
+        target: `${accountPackage(client, params.accountPackageId)}::account::set_delegate_protocol_permission`,
+        typeArguments: [`${resolvePackageId(client, params.predictionPackageId)}::account_data::WaterXPrediction`],
+        arguments: [
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            senderRequest,
+            idArg(tx, params.accountId),
+            tx.pure.address(params.delegate),
+            tx.pure.u32(params.permissions),
+            clockArg(tx),
+        ],
+    });
+    return tx;
+}
+export function whitelistPredictionProtocol(client, tx, params) {
+    tx.moveCall({
+        target: `${accountPackage(client, params.accountPackageId)}::account::whitelist_protocol`,
+        typeArguments: [`${resolvePackageId(client, params.predictionPackageId)}::account_data::WaterXPrediction`],
+        arguments: [
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            objectArg(tx, params.adminCap),
+        ],
+    });
+    return tx;
+}

package/dist/src/admin.d.ts

@@ -0,0 +1,47 @@
+import { Transaction } from "@mysten/sui/transactions";
+import type { PredictClient } from "./client.ts";
+import type { MarketIdInput, ObjectArgument } from "./types.ts";
+export interface AdminBaseParams {
+    packageId?: string;
+    marketRegistry?: string;
+    settlementCoinType?: string;
+}
+export interface CreateMarketRegistryParams extends AdminBaseParams {
+    adminCap: ObjectArgument;
+}
+export declare function createMarketRegistry(client: PredictClient, tx: Transaction, params: CreateMarketRegistryParams): Transaction;
+export interface DepositSettlementParams extends AdminBaseParams {
+    adminCap: ObjectArgument;
+    payment: ObjectArgument;
+}
+export declare function depositSettlement(client: PredictClient, tx: Transaction, params: DepositSettlementParams): Transaction;
+export interface AdminWithdrawParams extends AdminBaseParams {
+    adminCap: ObjectArgument;
+    amount: bigint | number | string;
+    recipient: string;
+}
+export declare function adminWithdraw(client: PredictClient, tx: Transaction, params: AdminWithdrawParams): Transaction;
+export interface SetMinReserveParams extends AdminBaseParams {
+    adminCap: ObjectArgument;
+    newReserve: bigint | number | string;
+}
+export declare function setMinReserve(client: PredictClient, tx: Transaction, params: SetMinReserveParams): Transaction;
+export interface SetOrderCancelCooldownParams extends AdminBaseParams {
+    adminCap: ObjectArgument;
+    cooldownMs: bigint | number | string;
+}
+export declare function setOrderCancelCooldownMs(client: PredictClient, tx: Transaction, params: SetOrderCancelCooldownParams): Transaction;
+export interface MarketPauseParams extends AdminBaseParams {
+    adminCap: ObjectArgument;
+    marketId: MarketIdInput;
+}
+export declare function pauseMarket(client: PredictClient, tx: Transaction, params: MarketPauseParams): Transaction;
+export declare function unpauseMarket(client: PredictClient, tx: Transaction, params: MarketPauseParams): Transaction;
+export interface KeeperAdminParams {
+    packageId?: string;
+    globalConfig?: string;
+    adminCap: ObjectArgument;
+    keeper: string;
+}
+export declare function addKeeper(client: PredictClient, tx: Transaction, params: KeeperAdminParams): Transaction;
+export declare function removeKeeper(client: PredictClient, tx: Transaction, params: KeeperAdminParams): Transaction;

package/dist/src/admin.js

@@ -0,0 +1,104 @@
+import { marketIdArg, objectArg, resolveGlobalConfig, resolveMarketRegistry, resolvePackageId, resolveSettlementCoinType, toBigInt, } from "./utils.js";
+export function createMarketRegistry(client, tx, params) {
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::waterx_prediction::create_market_registry`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [objectArg(tx, params.adminCap)],
+    });
+    return tx;
+}
+export function depositSettlement(client, tx, params) {
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::waterx_prediction::deposit_settlement`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [
+            objectArg(tx, params.adminCap),
+            tx.object(resolveMarketRegistry(client, params.marketRegistry)),
+            objectArg(tx, params.payment),
+        ],
+    });
+    return tx;
+}
+export function adminWithdraw(client, tx, params) {
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::waterx_prediction::admin_withdraw`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [
+            objectArg(tx, params.adminCap),
+            tx.object(resolveMarketRegistry(client, params.marketRegistry)),
+            tx.pure.u64(toBigInt(params.amount)),
+            tx.pure.address(params.recipient),
+        ],
+    });
+    return tx;
+}
+export function setMinReserve(client, tx, params) {
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::waterx_prediction::set_min_reserve`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [
+            objectArg(tx, params.adminCap),
+            tx.object(resolveMarketRegistry(client, params.marketRegistry)),
+            tx.pure.u64(toBigInt(params.newReserve)),
+        ],
+    });
+    return tx;
+}
+export function setOrderCancelCooldownMs(client, tx, params) {
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::waterx_prediction::set_order_cancel_cooldown_ms`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [
+            objectArg(tx, params.adminCap),
+            tx.object(resolveMarketRegistry(client, params.marketRegistry)),
+            tx.pure.u64(toBigInt(params.cooldownMs)),
+        ],
+    });
+    return tx;
+}
+export function pauseMarket(client, tx, params) {
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::waterx_prediction::pause_market`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [
+            objectArg(tx, params.adminCap),
+            tx.object(resolveMarketRegistry(client, params.marketRegistry)),
+            marketIdArg(tx, params.marketId),
+        ],
+    });
+    return tx;
+}
+export function unpauseMarket(client, tx, params) {
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::waterx_prediction::unpause_market`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [
+            objectArg(tx, params.adminCap),
+            tx.object(resolveMarketRegistry(client, params.marketRegistry)),
+            marketIdArg(tx, params.marketId),
+        ],
+    });
+    return tx;
+}
+export function addKeeper(client, tx, params) {
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::global_config::add_keeper`,
+        arguments: [
+            tx.object(resolveGlobalConfig(client, params.globalConfig)),
+            objectArg(tx, params.adminCap),
+            tx.pure.address(params.keeper),
+        ],
+    });
+    return tx;
+}
+export function removeKeeper(client, tx, params) {
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::global_config::remove_keeper`,
+        arguments: [
+            tx.object(resolveGlobalConfig(client, params.globalConfig)),
+            objectArg(tx, params.adminCap),
+            tx.pure.address(params.keeper),
+        ],
+    });
+    return tx;
+}

package/dist/src/bcs.d.ts

@@ -0,0 +1,20 @@
+import type { AccountDataView, CursorView, MarketView, OrderKind, OrderView, Outcome, PositionStatus, PositionView, RegistryView, Selection } from "./types.ts";
+export declare const OrderKindBcs: any;
+export declare const SelectionBcs: any;
+export declare const StatusBcs: any;
+export declare const OutcomeBcs: any;
+export declare const RegistryViewBcs: any;
+export declare const OrderViewBcs: any;
+export declare const PositionViewBcs: any;
+export declare const MarketViewBcs: any;
+export declare const AccountDataViewBcs: any;
+export declare function mapSelection(raw: unknown): Selection;
+export declare function mapOutcome(raw: unknown): Outcome;
+export declare function mapOrderKind(raw: unknown): OrderKind;
+export declare function mapStatus(raw: unknown): PositionStatus;
+export declare function mapRegistryView(raw: any): RegistryView;
+export declare function mapOrderView(raw: any): OrderView;
+export declare function mapPositionView(raw: any): PositionView;
+export declare function mapMarketView(raw: any): MarketView;
+export declare function mapAccountDataView(raw: any): AccountDataView;
+export declare function mapCursorView(count: unknown, front: unknown, back: unknown): CursorView;

package/dist/src/bcs.js

@@ -0,0 +1,209 @@
+import { bcs } from "@mysten/sui/bcs";
+import { bytesToHex, marketIdBytesFromUnknown } from "./utils.js";
+export const OrderKindBcs = bcs.enum("OrderKind", {
+    Open: null,
+    Close: null,
+});
+export const SelectionBcs = bcs.enum("Selection", {
+    No: null,
+    Yes: null,
+});
+export const StatusBcs = bcs.enum("Status", {
+    Open: null,
+    PendingClose: null,
+});
+export const OutcomeBcs = bcs.enum("Outcome", {
+    No: null,
+    Yes: null,
+    Invalid: null,
+});
+export const RegistryViewBcs = bcs.struct("RegistryView", {
+    balance: bcs.u64(),
+    min_reserve: bcs.u64(),
+    order_cancel_cooldown_ms: bcs.u64(),
+    next_order_id: bcs.u64(),
+    order_count: bcs.u64(),
+    position_count: bcs.u64(),
+    unresolved_market_count: bcs.u64(),
+    resolved_market_count: bcs.u64(),
+});
+export const OrderViewBcs = bcs.struct("OrderView", {
+    order_id: bcs.u64(),
+    kind: OrderKindBcs,
+    account_id: bcs.Address,
+    market_id: bcs.vector(bcs.u8()),
+    selection: SelectionBcs,
+    position_id: bcs.option(bcs.u64()),
+    max_spend: bcs.u64(),
+    min_shares: bcs.u64(),
+    price_cap: bcs.u64(),
+    min_proceeds: bcs.u64(),
+    expiry_ts: bcs.u64(),
+    self_cancel_after_ts: bcs.u64(),
+    by_admin: bcs.bool(),
+});
+export const PositionViewBcs = bcs.struct("PositionView", {
+    position_id: bcs.u64(),
+    account_id: bcs.Address,
+    market_id: bcs.vector(bcs.u8()),
+    selection: SelectionBcs,
+    status: StatusBcs,
+    filled_shares: bcs.u64(),
+    filled_cost: bcs.u64(),
+    payout: bcs.u64(),
+    close_order_id: bcs.option(bcs.u64()),
+    close_min_proceeds: bcs.u64(),
+    close_expiry_ts: bcs.u64(),
+    close_self_cancel_after_ts: bcs.u64(),
+});
+export const MarketViewBcs = bcs.struct("MarketView", {
+    market_key: bcs.u64(),
+    market_id: bcs.vector(bcs.u8()),
+    resolved: bcs.bool(),
+    paused: bcs.bool(),
+    outcome: bcs.option(OutcomeBcs),
+    unclaimed_count: bcs.u64(),
+});
+export const AccountDataViewBcs = bcs.struct("AccountDataView", {
+    account_id: bcs.Address,
+    has_data: bcs.bool(),
+    order_count: bcs.u64(),
+    position_count: bcs.u64(),
+    order_front: bcs.option(bcs.u64()),
+    order_back: bcs.option(bcs.u64()),
+    position_front: bcs.option(bcs.u64()),
+    position_back: bcs.option(bcs.u64()),
+});
+function enumKind(raw) {
+    if (typeof raw === "string")
+        return raw;
+    if (raw && typeof raw === "object") {
+        const record = raw;
+        if (typeof record.$kind === "string")
+            return record.$kind;
+        const key = Object.keys(record).find((k) => k !== "$kind");
+        if (key)
+            return key;
+    }
+    throw new Error(`Unable to decode enum variant: ${JSON.stringify(raw)}`);
+}
+export function mapSelection(raw) {
+    const kind = enumKind(raw).toLowerCase();
+    if (kind === "yes")
+        return "YES";
+    if (kind === "no")
+        return "NO";
+    throw new Error(`Unknown Selection variant: ${kind}`);
+}
+export function mapOutcome(raw) {
+    const kind = enumKind(raw).toLowerCase();
+    if (kind === "yes")
+        return "YES";
+    if (kind === "no")
+        return "NO";
+    if (kind === "invalid")
+        return "INVALID";
+    throw new Error(`Unknown Outcome variant: ${kind}`);
+}
+export function mapOrderKind(raw) {
+    const kind = enumKind(raw).toLowerCase();
+    if (kind === "open")
+        return "OPEN";
+    if (kind === "close")
+        return "CLOSE";
+    throw new Error(`Unknown OrderKind variant: ${kind}`);
+}
+export function mapStatus(raw) {
+    const kind = enumKind(raw).toLowerCase();
+    if (kind === "open")
+        return "OPEN";
+    if (kind === "pendingclose" || kind === "pending_close")
+        return "PENDING_CLOSE";
+    throw new Error(`Unknown Status variant: ${kind}`);
+}
+function mapOptionalU64(raw) {
+    return raw == null ? null : BigInt(raw);
+}
+function asBytes(raw) {
+    return marketIdBytesFromUnknown(raw);
+}
+export function mapRegistryView(raw) {
+    return {
+        balance: BigInt(raw.balance),
+        minReserve: BigInt(raw.min_reserve),
+        orderCancelCooldownMs: BigInt(raw.order_cancel_cooldown_ms),
+        nextOrderId: BigInt(raw.next_order_id),
+        orderCount: BigInt(raw.order_count),
+        positionCount: BigInt(raw.position_count),
+        unresolvedMarketCount: BigInt(raw.unresolved_market_count),
+        resolvedMarketCount: BigInt(raw.resolved_market_count),
+    };
+}
+export function mapOrderView(raw) {
+    const marketId = asBytes(raw.market_id);
+    return {
+        orderId: BigInt(raw.order_id),
+        kind: mapOrderKind(raw.kind),
+        accountId: raw.account_id,
+        marketId,
+        marketIdHex: bytesToHex(marketId),
+        selection: mapSelection(raw.selection),
+        positionId: mapOptionalU64(raw.position_id),
+        maxSpend: BigInt(raw.max_spend),
+        minShares: BigInt(raw.min_shares),
+        priceCapBps: BigInt(raw.price_cap),
+        minProceeds: BigInt(raw.min_proceeds),
+        expiryTs: BigInt(raw.expiry_ts),
+        selfCancelAfterTs: BigInt(raw.self_cancel_after_ts),
+        byAdmin: raw.by_admin,
+    };
+}
+export function mapPositionView(raw) {
+    const marketId = asBytes(raw.market_id);
+    return {
+        positionId: BigInt(raw.position_id),
+        accountId: raw.account_id,
+        marketId,
+        marketIdHex: bytesToHex(marketId),
+        selection: mapSelection(raw.selection),
+        status: mapStatus(raw.status),
+        filledShares: BigInt(raw.filled_shares),
+        filledCost: BigInt(raw.filled_cost),
+        payout: BigInt(raw.payout),
+        closeOrderId: mapOptionalU64(raw.close_order_id),
+        closeMinProceeds: BigInt(raw.close_min_proceeds),
+        closeExpiryTs: BigInt(raw.close_expiry_ts),
+        closeSelfCancelAfterTs: BigInt(raw.close_self_cancel_after_ts),
+    };
+}
+export function mapMarketView(raw) {
+    const marketId = asBytes(raw.market_id);
+    return {
+        marketKey: BigInt(raw.market_key),
+        marketId,
+        marketIdHex: bytesToHex(marketId),
+        resolved: raw.resolved,
+        paused: raw.paused,
+        outcome: raw.outcome == null ? null : mapOutcome(raw.outcome),
+        unclaimedCount: BigInt(raw.unclaimed_count),
+    };
+}
+export function mapAccountDataView(raw) {
+    return {
+        accountId: raw.account_id,
+        hasData: raw.has_data,
+        orderCount: BigInt(raw.order_count),
+        positionCount: BigInt(raw.position_count),
+        orderFront: mapOptionalU64(raw.order_front),
+        orderBack: mapOptionalU64(raw.order_back),
+        positionFront: mapOptionalU64(raw.position_front),
+        positionBack: mapOptionalU64(raw.position_back),
+    };
+}
+export function mapCursorView(count, front, back) {
+    return {
+        count: BigInt(count),
+        front: mapOptionalU64(front),
+        back: mapOptionalU64(back),
+    };
+}