@waterx/sdk 2.1.0 → 2.3.1-dev.0

package/dist/src/prediction/account.js

@@ -0,0 +1,230 @@
+import { bcs } from "@mysten/sui/bcs";
+import { Transaction } from "@mysten/sui/transactions";
+import { createAccountCall } from "../core/waterx-account.js";
+import { extractReturnBytes } from "./fetch.js";
+import { clockArg, createAccountRequest, idArg, objectArg, receivingCoinArg, resolveAccountRegistry, resolvePackageId, toBigInt, } from "./utils.js";
+function accountPackage(client, packageId) {
+    return packageId ?? client.waterxAccountPackageId();
+}
+/**
+ * Resolves the registry `0x2::object::ID` used by `request_deposit` / views from an on-chain
+ * `Account` object id (e.g. parsed from transaction effects).
+ */
+export async function resolveRegistryAccountId(client, accountObjectId, params = {}) {
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${accountPackage(client, params.accountPackageId)}::account::account_id`,
+        arguments: [tx.object(accountObjectId)],
+    });
+    const result = await client.simulate(tx);
+    return bcs.Address.parse(extractReturnBytes(result));
+}
+export function createAccount(client, tx, params) {
+    const senderRequest = createAccountRequest(client, tx, params);
+    return createAccountCall(tx, {
+        packageId: accountPackage(client, params.accountPackageId),
+        registry: resolveAccountRegistry(client, params.accountRegistry),
+    }, { senderRequest, alias: params.alias });
+}
+export function transferCoinToAccount(client, tx, params) {
+    tx.moveCall({
+        target: `${accountPackage(client, params.accountPackageId)}::account::transfer_coin`,
+        typeArguments: [params.coinType ?? client.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.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;
+}
+/** Finishes a `request_deposit` hot potato via `direct_rule` (same-coin credit). */
+export function consumeDepositDirect(client, tx, params) {
+    tx.moveCall({
+        target: `${accountPackage(client, params.accountPackageId)}::direct_rule::consume_deposit_direct`,
+        typeArguments: [params.coinType ?? client.settlementCoinType()],
+        arguments: [
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            params.depositRequest,
+        ],
+    });
+    return tx;
+}
+/**
+ * Full deposit: `request_deposit` + `consume_deposit_direct` in one PTB.
+ * Use this for testnet USD unless you implement a custom deposit policy consume path.
+ */
+export function deposit(client, tx, params) {
+    const request = requestDeposit(client, tx, params);
+    consumeDepositDirect(client, tx, {
+        accountPackageId: params.accountPackageId,
+        accountRegistry: params.accountRegistry,
+        depositRequest: request,
+        coinType: params.coinType,
+    });
+    return tx;
+}
+export function requestDepositFromReceivings(client, tx, params) {
+    const coinType = params.coinType ?? client.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.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;
+}
+/** Finishes a `request_withdraw` hot potato via `direct_rule` (same-coin payout). */
+export function consumeWithdrawDirect(client, tx, params) {
+    tx.moveCall({
+        target: `${accountPackage(client, params.accountPackageId)}::direct_rule::consume_withdraw_direct`,
+        typeArguments: [params.coinType ?? client.settlementCoinType()],
+        arguments: [
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            params.withdrawRequest,
+        ],
+    });
+    return tx;
+}
+/**
+ * Full withdraw: `request_withdraw` + `consume_withdraw_direct` in one PTB.
+ * Use this for testnet USD unless you implement a custom withdraw policy consume path.
+ */
+export function withdraw(client, tx, params) {
+    const request = requestWithdraw(client, tx, params);
+    consumeWithdrawDirect(client, tx, {
+        accountPackageId: params.accountPackageId,
+        accountRegistry: params.accountRegistry,
+        withdrawRequest: request,
+        coinType: params.coinType,
+    });
+    return tx;
+}
+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;
+}
+export function allowPredictionProtocolAsset(client, tx, params) {
+    tx.moveCall({
+        target: `${accountPackage(client, params.accountPackageId)}::account::allow_protocol_asset`,
+        typeArguments: [
+            `${resolvePackageId(client, params.predictionPackageId)}::account_data::WaterXPrediction`,
+            params.coinType ?? client.settlementCoinType(),
+        ],
+        arguments: [
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            objectArg(tx, params.adminCap),
+        ],
+    });
+    return tx;
+}
+export function disallowPredictionProtocolAsset(client, tx, params) {
+    tx.moveCall({
+        target: `${accountPackage(client, params.accountPackageId)}::account::disallow_protocol_asset`,
+        typeArguments: [
+            `${resolvePackageId(client, params.predictionPackageId)}::account_data::WaterXPrediction`,
+            params.coinType ?? client.settlementCoinType(),
+        ],
+        arguments: [
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            objectArg(tx, params.adminCap),
+        ],
+    });
+    return tx;
+}

package/dist/src/prediction/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/prediction/admin.js

@@ -0,0 +1,105 @@
+import { clockArg, 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),
+            clockArg(tx),
+        ],
+    });
+    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/prediction/bcs.d.ts

@@ -0,0 +1,22 @@
+import type { AccountDataView, CursorView, MarketExposure, 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 decodeEnumVariant(raw: unknown): string;
+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 mapMarketExposure(yesShares: unknown, yesCost: unknown, noShares: unknown, noCost: unknown): MarketExposure;
+export declare function mapAccountDataView(raw: any): AccountDataView;
+export declare function mapCursorView(count: unknown, front: unknown, back: unknown): CursorView;

package/dist/src/prediction/bcs.js

@@ -0,0 +1,240 @@
+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(),
+    created_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(),
+    opened_ts: 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(),
+    yes_shares: bcs.u64(),
+    yes_cost: bcs.u64(),
+    no_shares: bcs.u64(),
+    no_cost: 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()),
+});
+export function decodeEnumVariant(raw) {
+    if (typeof raw === "string")
+        return raw;
+    if (raw && typeof raw === "object") {
+        const record = raw;
+        if (typeof record.$kind === "string")
+            return record.$kind;
+        const variant = record["@variant"];
+        if (typeof variant === "string")
+            return variant;
+        if (variant && typeof variant === "object") {
+            const innerKey = Object.keys(variant)[0];
+            if (innerKey)
+                return innerKey;
+        }
+        const key = Object.keys(record).find((k) => k !== "$kind" && k !== "@variant");
+        if (key)
+            return key;
+    }
+    throw new Error(`Unable to decode enum variant: ${JSON.stringify(raw)}`);
+}
+function enumKind(raw) {
+    return decodeEnumVariant(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),
+        createdTs: BigInt(raw.created_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),
+        openedTs: BigInt(raw.opened_ts),
+        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),
+        yesShares: BigInt(raw.yes_shares),
+        yesCost: BigInt(raw.yes_cost),
+        noShares: BigInt(raw.no_shares),
+        noCost: BigInt(raw.no_cost),
+    };
+}
+export function mapMarketExposure(yesShares, yesCost, noShares, noCost) {
+    return {
+        yesShares: BigInt(yesShares),
+        yesCost: BigInt(yesCost),
+        noShares: BigInt(noShares),
+        noCost: BigInt(noCost),
+    };
+}
+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),
+    };
+}