@mysten/deepbook-v3 1.1.5 → 1.2.1

package/src/index.ts

@@ -37,6 +37,33 @@ export type {
 	Config,
 } from './types/index.js';
 
+// Named return types
+export type {
+	ManagerBalance,
+	VaultBalances,
+	LockedBalances,
+	ReferralBalances,
+	PoolTradeParams,
+	PoolBookParams,
+	PoolDeepPrice,
+	QuoteQuantityOut,
+	BaseQuantityOut,
+	QuantityOut,
+	BaseQuantityIn,
+	QuoteQuantityIn,
+	OrderDeepRequiredResult,
+	Level2Range,
+	Level2TicksFromMid,
+	AccountBalances,
+	AccountInfo,
+	DecodedOrderId,
+	MarginManagerState,
+	MarginManagerAssets,
+	MarginManagerDebts,
+	MarginManagerBalancesResult,
+	BorrowedShares,
+} from './types/index.js';
+
 // Trading parameter interfaces
 export type {
 	PlaceLimitOrderParams,

package/src/queries/accountQueries.ts

@@ -0,0 +1,117 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { bcs } from '@mysten/sui/bcs';
+import { Transaction } from '@mysten/sui/transactions';
+
+import { Account, OrderDeepPrice } from '../types/bcs.js';
+import type { AccountInfo, LockedBalances, PoolDeepPrice } from '../types/index.js';
+import { DEEP_SCALAR, FLOAT_SCALAR } from '../utils/config.js';
+import type { QueryContext } from './context.js';
+
+export class AccountQueries {
+	#ctx: QueryContext;
+
+	constructor(ctx: QueryContext) {
+		this.#ctx = ctx;
+	}
+
+	async account(poolKey: string, managerKey: string): Promise<AccountInfo> {
+		const tx = new Transaction();
+		const pool = this.#ctx.config.getPool(poolKey);
+		const baseScalar = this.#ctx.config.getCoin(pool.baseCoin).scalar;
+		const quoteScalar = this.#ctx.config.getCoin(pool.quoteCoin).scalar;
+
+		tx.add(this.#ctx.deepBook.account(poolKey, managerKey));
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const accountInformation = res.commandResults![0].returnValues[0].bcs;
+		const accountInfo = Account.parse(new Uint8Array(accountInformation));
+
+		return {
+			epoch: accountInfo.epoch,
+			open_orders: accountInfo.open_orders,
+			taker_volume: Number(accountInfo.taker_volume) / baseScalar,
+			maker_volume: Number(accountInfo.maker_volume) / baseScalar,
+			active_stake: Number(accountInfo.active_stake) / DEEP_SCALAR,
+			inactive_stake: Number(accountInfo.inactive_stake) / DEEP_SCALAR,
+			created_proposal: accountInfo.created_proposal,
+			voted_proposal: accountInfo.voted_proposal,
+			unclaimed_rebates: {
+				base: Number(accountInfo.unclaimed_rebates.base) / baseScalar,
+				quote: Number(accountInfo.unclaimed_rebates.quote) / quoteScalar,
+				deep: Number(accountInfo.unclaimed_rebates.deep) / DEEP_SCALAR,
+			},
+			settled_balances: {
+				base: Number(accountInfo.settled_balances.base) / baseScalar,
+				quote: Number(accountInfo.settled_balances.quote) / quoteScalar,
+				deep: Number(accountInfo.settled_balances.deep) / DEEP_SCALAR,
+			},
+			owed_balances: {
+				base: Number(accountInfo.owed_balances.base) / baseScalar,
+				quote: Number(accountInfo.owed_balances.quote) / quoteScalar,
+				deep: Number(accountInfo.owed_balances.deep) / DEEP_SCALAR,
+			},
+		};
+	}
+
+	async lockedBalance(poolKey: string, balanceManagerKey: string): Promise<LockedBalances> {
+		const tx = new Transaction();
+		const pool = this.#ctx.config.getPool(poolKey);
+		const baseScalar = this.#ctx.config.getCoin(pool.baseCoin).scalar;
+		const quoteScalar = this.#ctx.config.getCoin(pool.quoteCoin).scalar;
+
+		tx.add(this.#ctx.deepBook.lockedBalance(poolKey, balanceManagerKey));
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const baseLocked = Number(bcs.U64.parse(res.commandResults![0].returnValues[0].bcs));
+		const quoteLocked = Number(bcs.U64.parse(res.commandResults![0].returnValues[1].bcs));
+		const deepLocked = Number(bcs.U64.parse(res.commandResults![0].returnValues[2].bcs));
+
+		return {
+			base: Number((baseLocked / baseScalar).toFixed(9)),
+			quote: Number((quoteLocked / quoteScalar).toFixed(9)),
+			deep: Number((deepLocked / DEEP_SCALAR).toFixed(9)),
+		};
+	}
+
+	async getPoolDeepPrice(poolKey: string): Promise<PoolDeepPrice> {
+		const tx = new Transaction();
+		const pool = this.#ctx.config.getPool(poolKey);
+		tx.add(this.#ctx.deepBook.getPoolDeepPrice(poolKey));
+
+		const baseCoin = this.#ctx.config.getCoin(pool.baseCoin);
+		const quoteCoin = this.#ctx.config.getCoin(pool.quoteCoin);
+		const deepCoin = this.#ctx.config.getCoin('DEEP');
+
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const poolDeepPriceBytes = res.commandResults![0].returnValues[0].bcs;
+		const poolDeepPrice = OrderDeepPrice.parse(new Uint8Array(poolDeepPriceBytes));
+
+		if (poolDeepPrice.asset_is_base) {
+			return {
+				asset_is_base: poolDeepPrice.asset_is_base,
+				deep_per_base:
+					((Number(poolDeepPrice.deep_per_asset) / FLOAT_SCALAR) * baseCoin.scalar) /
+					deepCoin.scalar,
+			};
+		} else {
+			return {
+				asset_is_base: poolDeepPrice.asset_is_base,
+				deep_per_quote:
+					((Number(poolDeepPrice.deep_per_asset) / FLOAT_SCALAR) * quoteCoin.scalar) /
+					deepCoin.scalar,
+			};
+		}
+	}
+}

package/src/queries/balanceManagerQueries.ts

@@ -0,0 +1,156 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { bcs } from '@mysten/sui/bcs';
+import { Transaction } from '@mysten/sui/transactions';
+import { normalizeSuiAddress } from '@mysten/sui/utils';
+
+import type { ManagerBalance } from '../types/index.js';
+import type { QueryContext } from './context.js';
+
+export class BalanceManagerQueries {
+	#ctx: QueryContext;
+
+	constructor(ctx: QueryContext) {
+		this.#ctx = ctx;
+	}
+
+	async checkManagerBalance(managerKey: string, coinKey: string): Promise<ManagerBalance> {
+		const tx = new Transaction();
+		const coin = this.#ctx.config.getCoin(coinKey);
+
+		tx.add(this.#ctx.balanceManager.checkManagerBalance(managerKey, coinKey));
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const bytes = res.commandResults![0].returnValues[0].bcs;
+		const parsed_balance = bcs.U64.parse(bytes);
+		const balanceNumber = Number(parsed_balance);
+		const adjusted_balance = balanceNumber / coin.scalar;
+
+		return {
+			coinType: coin.type,
+			balance: Number(adjusted_balance.toFixed(9)),
+		};
+	}
+
+	async checkManagerBalanceWithAddress(
+		managerAddress: string,
+		coinKey: string,
+	): Promise<ManagerBalance> {
+		const tx = new Transaction();
+		const coin = this.#ctx.config.getCoin(coinKey);
+
+		tx.moveCall({
+			target: `${this.#ctx.config.DEEPBOOK_PACKAGE_ID}::balance_manager::balance`,
+			arguments: [tx.object(managerAddress)],
+			typeArguments: [coin.type],
+		});
+
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const bytes = res.commandResults![0].returnValues[0].bcs;
+		const parsed_balance = bcs.U64.parse(bytes);
+		const balanceNumber = Number(parsed_balance);
+		const adjusted_balance = balanceNumber / coin.scalar;
+
+		return {
+			coinType: coin.type,
+			balance: Number(adjusted_balance.toFixed(9)),
+		};
+	}
+
+	async checkManagerBalancesWithAddress(
+		managerAddresses: string[],
+		coinKeys: string[],
+	): Promise<Record<string, Record<string, number>>> {
+		if (managerAddresses.length === 0 || coinKeys.length === 0) {
+			return {};
+		}
+
+		const tx = new Transaction();
+		const coins = coinKeys.map((coinKey) => this.#ctx.config.getCoin(coinKey));
+
+		for (const managerAddress of managerAddresses) {
+			for (const coin of coins) {
+				tx.moveCall({
+					target: `${this.#ctx.config.DEEPBOOK_PACKAGE_ID}::balance_manager::balance`,
+					arguments: [tx.object(managerAddress)],
+					typeArguments: [coin.type],
+				});
+			}
+		}
+
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		if (res.FailedTransaction) {
+			throw new Error(
+				`Transaction failed: ${res.FailedTransaction.status.error?.message || 'Unknown error'}`,
+			);
+		}
+
+		if (!res.commandResults) {
+			throw new Error('Failed to get manager balances: No command results');
+		}
+
+		const results: Record<string, Record<string, number>> = {};
+
+		for (let m = 0; m < managerAddresses.length; m++) {
+			const managerAddress = managerAddresses[m];
+			const managerBalances: Record<string, number> = {};
+
+			for (let c = 0; c < coins.length; c++) {
+				const coin = coins[c];
+				const commandResult = res.commandResults[m * coins.length + c];
+
+				if (!commandResult || !commandResult.returnValues) {
+					throw new Error(`Failed to get balance for ${coin.type}: No return values`);
+				}
+
+				const bytes = commandResult.returnValues[0].bcs;
+				const parsed_balance = bcs.U64.parse(bytes);
+				managerBalances[coin.type] = Number((Number(parsed_balance) / coin.scalar).toFixed(9));
+			}
+
+			results[managerAddress] = managerBalances;
+		}
+
+		return results;
+	}
+
+	async getBalanceManagerIds(owner: string): Promise<string[]> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.deepBook.getBalanceManagerIds(owner));
+
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const bytes = res.commandResults![0].returnValues[0].bcs;
+		const vecOfAddresses = bcs.vector(bcs.Address).parse(bytes);
+
+		return vecOfAddresses.map((id: string) => normalizeSuiAddress(id));
+	}
+
+	async accountExists(poolKey: string, managerKey: string): Promise<boolean> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.deepBook.accountExists(poolKey, managerKey));
+
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const bytes = res.commandResults![0].returnValues[0].bcs;
+		return bcs.bool().parse(bytes);
+	}
+}

package/src/queries/context.ts

@@ -0,0 +1,44 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import type { DeepBookCompatibleClient } from '../client.js';
+import type { BalanceManagerContract } from '../transactions/balanceManager.js';
+import type { DeepBookContract } from '../transactions/deepbook.js';
+import type { MarginManagerContract } from '../transactions/marginManager.js';
+import type { MarginPoolContract } from '../transactions/marginPool.js';
+import type { MarginRegistryContract } from '../transactions/marginRegistry.js';
+import type { MarginTPSLContract } from '../transactions/marginTPSL.js';
+import type { DeepBookConfig } from '../utils/config.js';
+
+export interface QueryContext {
+	client: DeepBookCompatibleClient;
+	config: DeepBookConfig;
+	address: string;
+	balanceManager: BalanceManagerContract;
+	deepBook: DeepBookContract;
+	marginManager: MarginManagerContract;
+	marginPool: MarginPoolContract;
+	marginRegistry: MarginRegistryContract;
+	marginTPSL: MarginTPSLContract;
+}
+
+export function formatTokenAmount(rawAmount: bigint, scalar: number, decimals: number): string {
+	const scalarBigInt = BigInt(scalar);
+	const integerPart = rawAmount / scalarBigInt;
+	const fractionalPart = rawAmount % scalarBigInt;
+
+	if (fractionalPart === 0n) {
+		return integerPart.toString();
+	}
+
+	const scalarDigits = scalar.toString().length - 1;
+	const fractionalStr = fractionalPart.toString().padStart(scalarDigits, '0');
+	const truncated = fractionalStr.slice(0, decimals);
+	const trimmed = truncated.replace(/0+$/, '');
+
+	if (!trimmed) {
+		return integerPart.toString();
+	}
+
+	return `${integerPart}.${trimmed}`;
+}

package/src/queries/index.ts

@@ -0,0 +1,16 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+export { formatTokenAmount } from './context.js';
+export type { QueryContext } from './context.js';
+export { AccountQueries } from './accountQueries.js';
+export { BalanceManagerQueries } from './balanceManagerQueries.js';
+export { MarginManagerQueries } from './marginManagerQueries.js';
+export { MarginPoolQueries } from './marginPoolQueries.js';
+export { OrderQueries } from './orderQueries.js';
+export { PoolQueries } from './poolQueries.js';
+export { PriceFeedQueries } from './priceFeedQueries.js';
+export { QuantityQueries } from './quantityQueries.js';
+export { ReferralQueries } from './referralQueries.js';
+export { RegistryQueries } from './registryQueries.js';
+export { TPSLQueries } from './tpslQueries.js';