bomb-panic-sdk 0.1.0 → 0.1.2

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./read";
+export * from "./parse";
+export * from "./tx";
+export * from "./types";

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./read";
+export * from "./parse";
+export * from "./tx";
+export * from "./types";

package/dist/parse.d.ts

@@ -0,0 +1,9 @@
+import { ParsedGameState, ParsedRoom } from './types.js';
+type MoveObjectContent = {
+    dataType?: string;
+    type?: string;
+    fields?: any;
+};
+export declare function parseRoom(content: MoveObjectContent | undefined): ParsedRoom | null;
+export declare function parseGameState(content: MoveObjectContent | undefined): ParsedGameState | null;
+export {};

package/dist/parse.js

@@ -0,0 +1,143 @@
+function toBigInt(value) {
+    if (typeof value === 'bigint') {
+        return value;
+    }
+    if (typeof value === 'number') {
+        return BigInt(value);
+    }
+    if (typeof value === 'string' && value.length > 0) {
+        return BigInt(value);
+    }
+    return 0n;
+}
+function getObjectIdFromContent(content) {
+    if (!content || !content.fields)
+        return '';
+    return content.fields?.id?.id ?? content.fields?.id ?? '';
+}
+/**
+ * Parse Move Option<T> type which can be serialized in multiple formats:
+ * - { vec: [value] } or { vec: [] } (common format)
+ * - { fields: { vec: [value] } } (nested format)
+ * - Direct value (rare edge case)
+ *
+ * Returns null if None, or the value if Some.
+ */
+function parseOption(optionField) {
+    if (optionField === null || optionField === undefined) {
+        return null;
+    }
+    // Handle { vec: [...] } format
+    if (typeof optionField === 'object' && 'vec' in optionField) {
+        const vec = optionField.vec;
+        if (Array.isArray(vec) && vec.length > 0) {
+            return vec[0];
+        }
+        return null;
+    }
+    // Handle { fields: { vec: [...] } } format
+    if (typeof optionField === 'object' && 'fields' in optionField) {
+        const fields = optionField.fields;
+        if (fields && 'vec' in fields) {
+            const vec = fields.vec;
+            if (Array.isArray(vec) && vec.length > 0) {
+                return vec[0];
+            }
+        }
+        return null;
+    }
+    // Direct value (shouldn't happen for Option but handle defensively)
+    if (typeof optionField === 'string' && optionField.startsWith('0x')) {
+        return optionField;
+    }
+    return null;
+}
+export function parseRoom(content) {
+    if (!content || content.dataType !== 'moveObject')
+        return null;
+    const fields = content.fields ?? {};
+    const roomId = getObjectIdFromContent(content);
+    const status = fields.status?.variant ?? 'Unknown';
+    const entryFee = toBigInt(fields.entry_fee);
+    const maxPlayers = Number(fields.max_players ?? 0);
+    const playerCount = Number(fields.player_balances?.fields?.size ?? 0);
+    const poolValue = toBigInt(fields.pool?.fields?.value ?? fields.pool?.value ?? 0);
+    // Ready count: use ready_players table size
+    // The table contains all players who have called ready_to_play (value=true means ready)
+    // Since we can't iterate the table from serialized content, we use pool-based estimation
+    // When players ready, they deposit entry_fee into pool, so readyCount = poolValue / entryFee
+    // However, during Started status, pool may be drained, so we fall back to playerCount if pool is 0
+    let readyCount = 0;
+    if (status === 'Waiting' && entryFee > 0n && poolValue > 0n) {
+        readyCount = Number(poolValue / entryFee);
+    }
+    else if (status === 'Started' || status === 'Settled') {
+        // After game starts, assume all players were ready
+        readyCount = playerCount;
+    }
+    const readyTableId = fields.ready_players?.fields?.id?.id;
+    return {
+        roomId,
+        status,
+        entryFee,
+        maxPlayers,
+        playerCount,
+        poolValue,
+        readyCount,
+        readyTableId,
+    };
+}
+export function parseGameState(content) {
+    if (!content || content.dataType !== 'moveObject')
+        return null;
+    const fields = content.fields ?? {};
+    const gameId = getObjectIdFromContent(content);
+    const phase = fields.phase?.variant ?? 'Unknown';
+    const roundId = toBigInt(fields.round_id ?? 0);
+    // Parse bomb_holder Option<address> using the helper
+    const bombHolder = parseOption(fields.bomb_holder);
+    const holderStartMs = toBigInt(fields.holder_start_ms ?? 0);
+    const roundStartMs = toBigInt(fields.round_start_ms ?? 0);
+    const poolValue = toBigInt(fields.pool_value ?? 0);
+    const entryFeePerPlayer = toBigInt(fields.entry_fee_per_player ?? 0);
+    const rewardPerSec = toBigInt(fields.reward_per_sec ?? 0);
+    const explosionRateBps = toBigInt(fields.explosion_rate_bps ?? 0);
+    const settlementConsumed = Boolean(fields.settlement_consumed);
+    const roomId = fields.room_id ?? '';
+    const rewards = new Map();
+    const holderRewards = fields.holder_rewards ?? [];
+    if (Array.isArray(holderRewards)) {
+        holderRewards.forEach((r) => {
+            const addr = r?.fields?.player ?? '';
+            if (addr)
+                rewards.set(addr, toBigInt(r?.fields?.amount ?? 0));
+        });
+    }
+    const players = Array.isArray(fields.players)
+        ? fields.players.map((p) => {
+            const addr = p?.fields?.addr ?? '';
+            const reward = rewards.get(addr) ?? 0n;
+            return {
+                address: addr,
+                alive: Boolean(p?.fields?.alive),
+                reward,
+                isHolder: addr === bombHolder,
+            };
+        })
+        : [];
+    return {
+        gameId,
+        phase,
+        roundId,
+        bombHolder,
+        holderStartMs,
+        roundStartMs,
+        poolValue,
+        entryFeePerPlayer,
+        rewardPerSec,
+        explosionRateBps,
+        settlementConsumed,
+        roomId,
+        players,
+    };
+}

package/dist/read.d.ts

@@ -0,0 +1,14 @@
+import type { SuiClient } from '@onelabs/sui/client';
+import type { SuiObjectResponse } from '@onelabs/sui/client';
+import { ParsedGameState, ParsedRoom, RoomGamePair } from './types.js';
+export declare function getLobbyRoomIds(client: SuiClient, lobbyId: string, limit?: number): Promise<string[]>;
+export declare function getLobbyRoomGamePairs(client: SuiClient, lobbyId: string, limit?: number): Promise<RoomGamePair[]>;
+export declare function getRooms(client: SuiClient, roomIds: string[]): Promise<SuiObjectResponse[]>;
+export declare function getRoomAndGame(client: SuiClient, roomId: string, gameStateId: string): Promise<{
+    room: SuiObjectResponse;
+    game: SuiObjectResponse;
+}>;
+export declare function getRoomAndGameParsed(client: SuiClient, roomId: string, gameStateId: string): Promise<{
+    room: ParsedRoom | null;
+    game: ParsedGameState | null;
+}>;

package/dist/read.js

@@ -0,0 +1,127 @@
+import { parseGameState, parseRoom } from './parse.js';
+// Helper function to check if a MoveStruct has fields property
+function hasFields(fields) {
+    return fields !== null && typeof fields === 'object' && !Array.isArray(fields);
+}
+export async function getLobbyRoomIds(client, lobbyId, limit = 50) {
+    const lobbyObj = await client.getObject({
+        id: lobbyId,
+        options: { showContent: true },
+    });
+    const content = lobbyObj.data?.content;
+    if (!content || content.dataType !== 'moveObject') {
+        throw new Error('Lobby object not found or invalid');
+    }
+    const fields = content.fields;
+    if (!hasFields(fields)) {
+        throw new Error('Invalid lobby fields structure');
+    }
+    // After hasFields check, we know fields is an object
+    const roomToGame = fields.room_to_game;
+    if (!hasFields(roomToGame)) {
+        throw new Error('Invalid room_to_game structure');
+    }
+    const roomToGameFields = roomToGame.fields;
+    if (!hasFields(roomToGameFields)) {
+        throw new Error('Invalid room_to_game fields structure');
+    }
+    const id = roomToGameFields.id;
+    if (!hasFields(id)) {
+        throw new Error('Invalid id structure');
+    }
+    const roomToGameTableId = id.id;
+    if (typeof roomToGameTableId !== 'string') {
+        throw new Error('Lobby room_to_game table not found');
+    }
+    const roomEntries = await client.getDynamicFields({
+        parentId: roomToGameTableId,
+        limit,
+    });
+    return roomEntries.data.map(entry => entry.name.value);
+}
+export async function getLobbyRoomGamePairs(client, lobbyId, limit = 50) {
+    const lobbyObj = await client.getObject({
+        id: lobbyId,
+        options: { showContent: true },
+    });
+    const content = lobbyObj.data?.content;
+    if (!content || content.dataType !== 'moveObject') {
+        throw new Error('Lobby object not found or invalid');
+    }
+    const fields = content.fields;
+    if (!hasFields(fields)) {
+        throw new Error('Invalid lobby fields structure');
+    }
+    // After hasFields check, we know fields is an object
+    const roomToGame = fields.room_to_game;
+    if (!hasFields(roomToGame)) {
+        throw new Error('Invalid room_to_game structure');
+    }
+    const roomToGameFields = roomToGame.fields;
+    if (!hasFields(roomToGameFields)) {
+        throw new Error('Invalid room_to_game fields structure');
+    }
+    const id = roomToGameFields.id;
+    if (!hasFields(id)) {
+        throw new Error('Invalid id structure');
+    }
+    const roomToGameTableId = id.id;
+    if (typeof roomToGameTableId !== 'string') {
+        throw new Error('Lobby room_to_game table not found');
+    }
+    const roomEntries = await client.getDynamicFields({
+        parentId: roomToGameTableId,
+        limit,
+    });
+    const pairs = [];
+    for (const entry of roomEntries.data) {
+        const fieldObj = await client.getDynamicFieldObject({
+            parentId: roomToGameTableId,
+            name: entry.name,
+        });
+        const fieldContent = fieldObj.data?.content;
+        let gameStateId = null;
+        if (fieldContent && fieldContent.dataType === 'moveObject') {
+            const fieldFields = fieldContent.fields;
+            if (hasFields(fieldFields)) {
+                // After hasFields check, we know fieldFields is an object
+                const value = fieldFields.value;
+                if (typeof value === 'string') {
+                    gameStateId = value;
+                }
+            }
+        }
+        pairs.push({ roomId: entry.name.value, gameStateId });
+    }
+    return pairs;
+}
+export async function getRooms(client, roomIds) {
+    if (roomIds.length === 0)
+        return [];
+    return client.multiGetObjects({
+        ids: roomIds,
+        options: { showContent: true, showType: true },
+    });
+}
+export async function getRoomAndGame(client, roomId, gameStateId) {
+    const response = await client.multiGetObjects({
+        ids: [roomId, gameStateId],
+        options: { showContent: true },
+    });
+    const [room, game] = response;
+    return { room, game };
+}
+export async function getRoomAndGameParsed(client, roomId, gameStateId) {
+    const { room, game } = await getRoomAndGame(client, roomId, gameStateId);
+    // Convert SuiParsedData to the format expected by parse functions
+    const roomContent = room.data?.content?.dataType === 'moveObject'
+        ? room.data.content
+        : undefined;
+    const gameContent = game.data?.content?.dataType === 'moveObject'
+        ? game.data.content
+        : undefined;
+    return {
+        room: parseRoom(roomContent),
+        game: parseGameState(gameContent),
+    };
+}

package/dist/tx.d.ts

@@ -0,0 +1,65 @@
+import { Transaction } from '@onelabs/sui/transactions';
+import { SdkConfig } from './types.js';
+export declare function buildCreateRoomTx(config: SdkConfig, args: {
+    gameRegistryId: string;
+    configId: string;
+    entryFee: bigint | number | string;
+    maxPlayers: number;
+    creationFee: bigint | number | string;
+    gameType?: string;
+}): Transaction;
+export declare function buildCreateGameForRoomTx(config: SdkConfig, args: {
+    lobbyId: string;
+    roomId: string;
+}): Transaction;
+export declare function buildJoinTx(config: SdkConfig, args: {
+    roomId: string;
+    gameStateId: string;
+}): Transaction;
+export declare function buildReadyTx(config: SdkConfig, args: {
+    roomId: string;
+    entryFee: bigint | number | string;
+}): Transaction;
+export declare function buildJoinAndReadyTx(config: SdkConfig, args: {
+    roomId: string;
+    gameStateId: string;
+    entryFee: bigint | number | string;
+}): Transaction;
+export declare function buildReadyNextRoundTx(config: SdkConfig, args: {
+    roomId: string;
+    entryFee: bigint | number | string;
+}): Transaction;
+export declare function buildCancelReadyTx(config: SdkConfig, args: {
+    roomId: string;
+}): Transaction;
+export declare function buildLeaveRoomTx(config: SdkConfig, args: {
+    roomId: string;
+}): Transaction;
+export declare function buildLeaveGameTx(config: SdkConfig, args: {
+    gameStateId: string;
+}): Transaction;
+export declare function buildLeaveRoomAndGameTx(config: SdkConfig, args: {
+    roomId: string;
+    gameStateId: string;
+}): Transaction;
+export declare function buildPassBombTx(config: SdkConfig, args: {
+    gameStateId: string;
+}): Transaction;
+export declare function buildStartRoundWithHubTx(config: SdkConfig, args: {
+    gameStateId: string;
+    roomId: string;
+    adminCapId: string;
+    configId: string;
+}): Transaction;
+export declare function buildTryExplodeTx(config: SdkConfig, args: {
+    gameStateId: string;
+}): Transaction;
+export declare function buildSettleRoundWithHubTx(config: SdkConfig, args: {
+    gameStateId: string;
+    roomId: string;
+    gameCapId: string;
+}): Transaction;
+export declare function buildPrepareNextRoundTx(config: SdkConfig, args: {
+    gameStateId: string;
+    newRoomId: string;
+}): Transaction;

package/dist/tx.js

@@ -0,0 +1,201 @@
+import { Transaction } from '@onelabs/sui/transactions';
+const DEFAULT_RANDOM = '0x8';
+const DEFAULT_CLOCK = '0x6';
+function toU64(value) {
+    return typeof value === 'bigint' ? value : BigInt(value);
+}
+function getGameType(packageId, coinType) {
+    return `${packageId}::bomb_panic::GameState<${coinType}>`;
+}
+export function buildCreateRoomTx(config, args) {
+    const tx = new Transaction();
+    const [creationFeeCoin] = tx.splitCoins(tx.gas, [tx.pure.u64(toU64(args.creationFee))]);
+    tx.moveCall({
+        target: `${config.packageId}::gamehub::create_room`,
+        arguments: [
+            tx.object(args.gameRegistryId),
+            tx.object(args.configId),
+            tx.pure.u64(toU64(args.entryFee)),
+            tx.pure.u8(args.maxPlayers),
+            creationFeeCoin,
+        ],
+        typeArguments: [
+            config.coinType,
+            args.gameType ?? getGameType(config.packageId, config.coinType),
+        ],
+    });
+    return tx;
+}
+export function buildCreateGameForRoomTx(config, args) {
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${config.packageId}::bomb_panic::create_game_for_room`,
+        arguments: [tx.object(args.lobbyId), tx.pure.address(args.roomId)],
+        typeArguments: [config.coinType],
+    });
+    return tx;
+}
+export function buildJoinTx(config, args) {
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${config.packageId}::gamehub::join_room`,
+        arguments: [tx.object(args.roomId)],
+        typeArguments: [config.coinType],
+    });
+    tx.moveCall({
+        target: `${config.packageId}::bomb_panic::join`,
+        arguments: [tx.object(args.gameStateId)],
+        typeArguments: [config.coinType],
+    });
+    return tx;
+}
+export function buildReadyTx(config, args) {
+    const tx = new Transaction();
+    const [entryCoin] = tx.splitCoins(tx.gas, [tx.pure.u64(toU64(args.entryFee))]);
+    tx.moveCall({
+        target: `${config.packageId}::gamehub::ready_to_play`,
+        arguments: [tx.object(args.roomId), entryCoin],
+        typeArguments: [config.coinType],
+    });
+    return tx;
+}
+export function buildJoinAndReadyTx(config, args) {
+    const tx = new Transaction();
+    const [entryCoin] = tx.splitCoins(tx.gas, [tx.pure.u64(toU64(args.entryFee))]);
+    tx.moveCall({
+        target: `${config.packageId}::gamehub::join_room`,
+        arguments: [tx.object(args.roomId)],
+        typeArguments: [config.coinType],
+    });
+    tx.moveCall({
+        target: `${config.packageId}::bomb_panic::join`,
+        arguments: [tx.object(args.gameStateId)],
+        typeArguments: [config.coinType],
+    });
+    tx.moveCall({
+        target: `${config.packageId}::gamehub::ready_to_play`,
+        arguments: [tx.object(args.roomId), entryCoin],
+        typeArguments: [config.coinType],
+    });
+    return tx;
+}
+export function buildReadyNextRoundTx(config, args) {
+    const tx = new Transaction();
+    const [entryCoin] = tx.splitCoins(tx.gas, [tx.pure.u64(toU64(args.entryFee))]);
+    tx.moveCall({
+        target: `${config.packageId}::gamehub::join_room`,
+        arguments: [tx.object(args.roomId)],
+        typeArguments: [config.coinType],
+    });
+    tx.moveCall({
+        target: `${config.packageId}::gamehub::ready_to_play`,
+        arguments: [tx.object(args.roomId), entryCoin],
+        typeArguments: [config.coinType],
+    });
+    return tx;
+}
+export function buildCancelReadyTx(config, args) {
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${config.packageId}::gamehub::cancel_ready`,
+        arguments: [tx.object(args.roomId)],
+        typeArguments: [config.coinType],
+    });
+    return tx;
+}
+export function buildLeaveRoomTx(config, args) {
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${config.packageId}::gamehub::leave_room`,
+        arguments: [tx.object(args.roomId)],
+        typeArguments: [config.coinType],
+    });
+    return tx;
+}
+export function buildLeaveGameTx(config, args) {
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${config.packageId}::bomb_panic::leave`,
+        arguments: [tx.object(args.gameStateId), tx.object(config.clockId ?? DEFAULT_CLOCK)],
+        typeArguments: [config.coinType],
+    });
+    return tx;
+}
+export function buildLeaveRoomAndGameTx(config, args) {
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${config.packageId}::gamehub::leave_room`,
+        arguments: [tx.object(args.roomId)],
+        typeArguments: [config.coinType],
+    });
+    tx.moveCall({
+        target: `${config.packageId}::bomb_panic::leave`,
+        arguments: [tx.object(args.gameStateId), tx.object(config.clockId ?? DEFAULT_CLOCK)],
+        typeArguments: [config.coinType],
+    });
+    return tx;
+}
+export function buildPassBombTx(config, args) {
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${config.packageId}::bomb_panic::pass_bomb`,
+        arguments: [
+            tx.object(config.randomId ?? DEFAULT_RANDOM),
+            tx.object(args.gameStateId),
+            tx.object(config.clockId ?? DEFAULT_CLOCK),
+        ],
+        typeArguments: [config.coinType],
+    });
+    return tx;
+}
+export function buildStartRoundWithHubTx(config, args) {
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${config.packageId}::bomb_panic::start_round_with_hub`,
+        arguments: [
+            tx.object(config.randomId ?? DEFAULT_RANDOM),
+            tx.object(args.gameStateId),
+            tx.object(args.roomId),
+            tx.object(config.clockId ?? DEFAULT_CLOCK),
+            tx.object(args.adminCapId),
+            tx.object(args.configId),
+        ],
+        typeArguments: [config.coinType],
+    });
+    return tx;
+}
+export function buildTryExplodeTx(config, args) {
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${config.packageId}::bomb_panic::try_explode`,
+        arguments: [
+            tx.object(args.gameStateId),
+            tx.object(config.clockId ?? DEFAULT_CLOCK),
+            tx.object(config.randomId ?? DEFAULT_RANDOM),
+        ],
+        typeArguments: [config.coinType],
+    });
+    return tx;
+}
+export function buildSettleRoundWithHubTx(config, args) {
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${config.packageId}::bomb_panic::settle_round_with_hub`,
+        arguments: [
+            tx.object(args.gameStateId),
+            tx.object(args.roomId),
+            tx.object(args.gameCapId),
+        ],
+        typeArguments: [config.coinType],
+    });
+    return tx;
+}
+export function buildPrepareNextRoundTx(config, args) {
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${config.packageId}::bomb_panic::prepare_next_round`,
+        arguments: [tx.object(args.gameStateId), tx.pure.address(args.newRoomId)],
+        typeArguments: [config.coinType],
+    });
+    return tx;
+}

package/dist/types.d.ts

@@ -0,0 +1,43 @@
+export type SdkConfig = {
+    packageId: string;
+    coinType: string;
+    randomId?: string;
+    clockId?: string;
+};
+export type RoomStatus = 'Waiting' | 'Started' | 'Cancelled' | 'Settled' | string;
+export type GamePhase = 'Waiting' | 'Playing' | 'Ended' | string;
+export type ParsedRoom = {
+    roomId: string;
+    status: RoomStatus;
+    entryFee: bigint;
+    maxPlayers: number;
+    playerCount: number;
+    poolValue: bigint;
+    readyCount: number;
+    readyTableId?: string;
+};
+export type ParsedPlayer = {
+    address: string;
+    alive: boolean;
+    reward: bigint;
+    isHolder: boolean;
+};
+export type ParsedGameState = {
+    gameId: string;
+    phase: GamePhase;
+    roundId: bigint;
+    bombHolder: string | null;
+    holderStartMs: bigint;
+    roundStartMs: bigint;
+    poolValue: bigint;
+    entryFeePerPlayer: bigint;
+    rewardPerSec: bigint;
+    explosionRateBps: bigint;
+    settlementConsumed: boolean;
+    roomId: string;
+    players: ParsedPlayer[];
+};
+export type RoomGamePair = {
+    roomId: string;
+    gameStateId: string | null;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,11 +1,18 @@
 {
   "name": "bomb-panic-sdk",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": ["dist", "README.md", "LICENSE"],
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
     "build": "tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "bomb-panic-sdk": "^0.1.0"
   }
 }