@haneullabs/deepbook-v3 0.1.0 → 1.2.1

package/src/queries/marginPoolQueries.ts

@@ -0,0 +1,226 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { bcs } from '@haneullabs/haneul/bcs';
+import { Transaction } from '@haneullabs/haneul/transactions';
+
+import { FLOAT_SCALAR } from '../utils/config.js';
+import { formatTokenAmount } from './context.js';
+import type { QueryContext } from './context.js';
+
+export class MarginPoolQueries {
+	#ctx: QueryContext;
+
+	constructor(ctx: QueryContext) {
+		this.#ctx = ctx;
+	}
+
+	async getMarginPoolId(coinKey: string): Promise<string> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.marginPool.getId(coinKey));
+
+		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.Address.parse(bytes);
+	}
+
+	async isDeepbookPoolAllowed(coinKey: string, deepbookPoolId: string): Promise<boolean> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.marginPool.deepbookPoolAllowed(coinKey, deepbookPoolId));
+
+		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);
+	}
+
+	async getMarginPoolTotalSupply(coinKey: string, decimals: number = 6): Promise<string> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.marginPool.totalSupply(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 rawAmount = BigInt(bcs.U64.parse(bytes));
+		const coin = this.#ctx.config.getCoin(coinKey);
+		return formatTokenAmount(rawAmount, coin.scalar, decimals);
+	}
+
+	async getMarginPoolSupplyShares(coinKey: string, decimals: number = 6): Promise<string> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.marginPool.supplyShares(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 rawShares = BigInt(bcs.U64.parse(bytes));
+		const coin = this.#ctx.config.getCoin(coinKey);
+		return formatTokenAmount(rawShares, coin.scalar, decimals);
+	}
+
+	async getMarginPoolTotalBorrow(coinKey: string, decimals: number = 6): Promise<string> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.marginPool.totalBorrow(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 rawAmount = BigInt(bcs.U64.parse(bytes));
+		const coin = this.#ctx.config.getCoin(coinKey);
+		return formatTokenAmount(rawAmount, coin.scalar, decimals);
+	}
+
+	async getMarginPoolBorrowShares(coinKey: string, decimals: number = 6): Promise<string> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.marginPool.borrowShares(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 rawShares = BigInt(bcs.U64.parse(bytes));
+		const coin = this.#ctx.config.getCoin(coinKey);
+		return formatTokenAmount(rawShares, coin.scalar, decimals);
+	}
+
+	async getMarginPoolLastUpdateTimestamp(coinKey: string): Promise<number> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.marginPool.lastUpdateTimestamp(coinKey));
+
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const bytes = res.commandResults![0].returnValues[0].bcs;
+		return Number(bcs.U64.parse(bytes));
+	}
+
+	async getMarginPoolSupplyCap(coinKey: string, decimals: number = 6): Promise<string> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.marginPool.supplyCap(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 rawAmount = BigInt(bcs.U64.parse(bytes));
+		const coin = this.#ctx.config.getCoin(coinKey);
+		return formatTokenAmount(rawAmount, coin.scalar, decimals);
+	}
+
+	async getMarginPoolMaxUtilizationRate(coinKey: string): Promise<number> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.marginPool.maxUtilizationRate(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 rawRate = Number(bcs.U64.parse(bytes));
+		return rawRate / FLOAT_SCALAR;
+	}
+
+	async getMarginPoolProtocolSpread(coinKey: string): Promise<number> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.marginPool.protocolSpread(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 rawSpread = Number(bcs.U64.parse(bytes));
+		return rawSpread / FLOAT_SCALAR;
+	}
+
+	async getMarginPoolMinBorrow(coinKey: string, decimals: number = 6): Promise<string> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.marginPool.minBorrow(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 rawAmount = BigInt(bcs.U64.parse(bytes));
+		const coin = this.#ctx.config.getCoin(coinKey);
+		return formatTokenAmount(rawAmount, coin.scalar, decimals);
+	}
+
+	async getMarginPoolInterestRate(coinKey: string): Promise<number> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.marginPool.interestRate(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 rawRate = Number(bcs.U64.parse(bytes));
+		return rawRate / FLOAT_SCALAR;
+	}
+
+	async getUserSupplyShares(
+		coinKey: string,
+		supplierCapId: string,
+		decimals: number = 6,
+	): Promise<string> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.marginPool.userSupplyShares(coinKey, supplierCapId));
+
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const bytes = res.commandResults![0].returnValues[0].bcs;
+		const rawShares = BigInt(bcs.U64.parse(bytes));
+		const coin = this.#ctx.config.getCoin(coinKey);
+		return formatTokenAmount(rawShares, coin.scalar, decimals);
+	}
+
+	async getUserSupplyAmount(
+		coinKey: string,
+		supplierCapId: string,
+		decimals: number = 6,
+	): Promise<string> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.marginPool.userSupplyAmount(coinKey, supplierCapId));
+
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const bytes = res.commandResults![0].returnValues[0].bcs;
+		const rawAmount = BigInt(bcs.U64.parse(bytes));
+		const coin = this.#ctx.config.getCoin(coinKey);
+		return formatTokenAmount(rawAmount, coin.scalar, decimals);
+	}
+}

package/src/queries/orderQueries.ts

@@ -0,0 +1,202 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { bcs } from '@haneullabs/haneul/bcs';
+import { Transaction } from '@haneullabs/haneul/transactions';
+
+import { Order } from '../types/bcs.js';
+import { VecSet } from '../types/bcs.js';
+import type { Level2Range, Level2TicksFromMid } from '../types/index.js';
+import { DEEP_SCALAR, FLOAT_SCALAR } from '../utils/config.js';
+import type { QueryContext } from './context.js';
+
+export class OrderQueries {
+	#ctx: QueryContext;
+
+	constructor(ctx: QueryContext) {
+		this.#ctx = ctx;
+	}
+
+	async accountOpenOrders(poolKey: string, managerKey: string): Promise<string[]> {
+		const tx = new Transaction();
+
+		tx.add(this.#ctx.deepBook.accountOpenOrders(poolKey, managerKey));
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const order_ids = res.commandResults![0].returnValues[0].bcs;
+
+		return VecSet(bcs.u128()).parse(new Uint8Array(order_ids)).contents;
+	}
+
+	async getOrder(poolKey: string, orderId: string): Promise<ReturnType<typeof Order.parse> | null> {
+		const tx = new Transaction();
+
+		tx.add(this.#ctx.deepBook.getOrder(poolKey, orderId));
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		try {
+			const orderInformation = res.commandResults![0].returnValues[0].bcs;
+			return Order.parse(new Uint8Array(orderInformation));
+		} catch {
+			return null;
+		}
+	}
+
+	async getOrderNormalized(poolKey: string, orderId: string) {
+		const tx = new Transaction();
+		tx.add(this.#ctx.deepBook.getOrder(poolKey, orderId));
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		try {
+			const orderInformation = res.commandResults![0].returnValues[0].bcs;
+			const orderInfo = Order.parse(new Uint8Array(orderInformation));
+
+			if (!orderInfo) {
+				return null;
+			}
+			const baseCoin = this.#ctx.config.getCoin(this.#ctx.config.getPool(poolKey).baseCoin);
+			const quoteCoin = this.#ctx.config.getCoin(this.#ctx.config.getPool(poolKey).quoteCoin);
+
+			const encodedOrderId = BigInt(orderInfo.order_id);
+			const isBid = encodedOrderId >> 127n === 0n;
+			const rawPrice = Number((encodedOrderId >> 64n) & ((1n << 63n) - 1n));
+			const normalizedPrice = (rawPrice * baseCoin.scalar) / quoteCoin.scalar / FLOAT_SCALAR;
+
+			const normalizedOrderInfo = {
+				...orderInfo,
+				quantity: String((Number(orderInfo.quantity) / baseCoin.scalar).toFixed(9)),
+				filled_quantity: String((Number(orderInfo.filled_quantity) / baseCoin.scalar).toFixed(9)),
+				order_deep_price: {
+					...orderInfo.order_deep_price,
+					deep_per_asset: String(
+						(Number(orderInfo.order_deep_price.deep_per_asset) / DEEP_SCALAR).toFixed(9),
+					),
+				},
+				isBid,
+				normalized_price: normalizedPrice.toFixed(9),
+			};
+			return normalizedOrderInfo;
+		} catch {
+			return null;
+		}
+	}
+
+	async getOrders(
+		poolKey: string,
+		orderIds: string[],
+	): Promise<ReturnType<typeof Order.parse>[] | null> {
+		const tx = new Transaction();
+
+		tx.add(this.#ctx.deepBook.getOrders(poolKey, orderIds));
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		try {
+			const orderInformation = res.commandResults![0].returnValues[0].bcs;
+			return bcs.vector(Order).parse(new Uint8Array(orderInformation));
+		} catch {
+			return null;
+		}
+	}
+
+	async getLevel2Range(
+		poolKey: string,
+		priceLow: number | bigint,
+		priceHigh: number | bigint,
+		isBid: boolean,
+	): Promise<Level2Range> {
+		const tx = new Transaction();
+		const pool = this.#ctx.config.getPool(poolKey);
+		const baseCoin = this.#ctx.config.getCoin(pool.baseCoin);
+		const quoteCoin = this.#ctx.config.getCoin(pool.quoteCoin);
+
+		tx.add(this.#ctx.deepBook.getLevel2Range(poolKey, priceLow, priceHigh, isBid));
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const prices = res.commandResults![0].returnValues[0].bcs;
+		const parsed_prices = bcs.vector(bcs.u64()).parse(new Uint8Array(prices));
+		const quantities = res.commandResults![0].returnValues[1].bcs;
+		const parsed_quantities = bcs.vector(bcs.u64()).parse(new Uint8Array(quantities));
+
+		return {
+			prices: parsed_prices.map((price) =>
+				Number(((Number(price) / FLOAT_SCALAR / quoteCoin.scalar) * baseCoin.scalar).toFixed(9)),
+			),
+			quantities: parsed_quantities.map((price) =>
+				Number((Number(price) / baseCoin.scalar).toFixed(9)),
+			),
+		};
+	}
+
+	async getLevel2TicksFromMid(poolKey: string, ticks: number): Promise<Level2TicksFromMid> {
+		const tx = new Transaction();
+		const pool = this.#ctx.config.getPool(poolKey);
+		const baseCoin = this.#ctx.config.getCoin(pool.baseCoin);
+		const quoteCoin = this.#ctx.config.getCoin(pool.quoteCoin);
+
+		tx.add(this.#ctx.deepBook.getLevel2TicksFromMid(poolKey, ticks));
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const bid_prices = res.commandResults![0].returnValues[0].bcs;
+		const bid_parsed_prices = bcs.vector(bcs.u64()).parse(new Uint8Array(bid_prices));
+		const bid_quantities = res.commandResults![0].returnValues[1].bcs;
+		const bid_parsed_quantities = bcs.vector(bcs.u64()).parse(new Uint8Array(bid_quantities));
+
+		const ask_prices = res.commandResults![0].returnValues[2].bcs;
+		const ask_parsed_prices = bcs.vector(bcs.u64()).parse(new Uint8Array(ask_prices));
+		const ask_quantities = res.commandResults![0].returnValues[3].bcs;
+		const ask_parsed_quantities = bcs.vector(bcs.u64()).parse(new Uint8Array(ask_quantities));
+
+		return {
+			bid_prices: bid_parsed_prices.map((price) =>
+				Number(((Number(price) / FLOAT_SCALAR / quoteCoin.scalar) * baseCoin.scalar).toFixed(9)),
+			),
+			bid_quantities: bid_parsed_quantities.map((quantity) =>
+				Number((Number(quantity) / baseCoin.scalar).toFixed(9)),
+			),
+			ask_prices: ask_parsed_prices.map((price) =>
+				Number(((Number(price) / FLOAT_SCALAR / quoteCoin.scalar) * baseCoin.scalar).toFixed(9)),
+			),
+			ask_quantities: ask_parsed_quantities.map((quantity) =>
+				Number((Number(quantity) / baseCoin.scalar).toFixed(9)),
+			),
+		};
+	}
+
+	async getAccountOrderDetails(
+		poolKey: string,
+		managerKey: string,
+	): Promise<ReturnType<typeof Order.parse>[] | []> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.deepBook.getAccountOrderDetails(poolKey, managerKey));
+
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		try {
+			const orderInformation = res.commandResults![0].returnValues[0].bcs;
+			return bcs.vector(Order).parse(new Uint8Array(orderInformation));
+		} catch {
+			return [];
+		}
+	}
+}

package/src/queries/poolQueries.ts

@@ -0,0 +1,266 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { bcs } from '@haneullabs/haneul/bcs';
+import { Transaction } from '@haneullabs/haneul/transactions';
+import { normalizeHaneulAddress } from '@haneullabs/haneul/utils';
+
+import type {
+	CanPlaceLimitOrderParams,
+	CanPlaceMarketOrderParams,
+	PoolBookParams,
+	PoolTradeParams,
+	VaultBalances,
+} from '../types/index.js';
+import { DEEP_SCALAR, FLOAT_SCALAR } from '../utils/config.js';
+import type { QueryContext } from './context.js';
+
+export class PoolQueries {
+	#ctx: QueryContext;
+
+	constructor(ctx: QueryContext) {
+		this.#ctx = ctx;
+	}
+
+	async whitelisted(poolKey: string): Promise<boolean> {
+		const tx = new Transaction();
+
+		tx.add(this.#ctx.deepBook.whitelisted(poolKey));
+		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);
+	}
+
+	async vaultBalances(poolKey: string): Promise<VaultBalances> {
+		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.vaultBalances(poolKey));
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const baseInVault = Number(bcs.U64.parse(res.commandResults![0].returnValues[0].bcs));
+		const quoteInVault = Number(bcs.U64.parse(res.commandResults![0].returnValues[1].bcs));
+		const deepInVault = Number(bcs.U64.parse(res.commandResults![0].returnValues[2].bcs));
+
+		return {
+			base: Number((baseInVault / baseScalar).toFixed(9)),
+			quote: Number((quoteInVault / quoteScalar).toFixed(9)),
+			deep: Number((deepInVault / DEEP_SCALAR).toFixed(9)),
+		};
+	}
+
+	async getPoolIdByAssets(baseType: string, quoteType: string): Promise<string> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.deepBook.getPoolIdByAssets(baseType, quoteType));
+
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		return bcs.Address.parse(res.commandResults![0].returnValues[0].bcs);
+	}
+
+	async midPrice(poolKey: string): Promise<number> {
+		const tx = new Transaction();
+		const pool = this.#ctx.config.getPool(poolKey);
+		tx.add(this.#ctx.deepBook.midPrice(poolKey));
+
+		const baseCoin = this.#ctx.config.getCoin(pool.baseCoin);
+		const quoteCoin = this.#ctx.config.getCoin(pool.quoteCoin);
+
+		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_mid_price = Number(bcs.U64.parse(bytes));
+		const adjusted_mid_price =
+			(parsed_mid_price * baseCoin.scalar) / quoteCoin.scalar / FLOAT_SCALAR;
+
+		return Number(adjusted_mid_price.toFixed(9));
+	}
+
+	async poolTradeParams(poolKey: string): Promise<PoolTradeParams> {
+		const tx = new Transaction();
+
+		tx.add(this.#ctx.deepBook.poolTradeParams(poolKey));
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const takerFee = Number(bcs.U64.parse(res.commandResults![0].returnValues[0].bcs));
+		const makerFee = Number(bcs.U64.parse(res.commandResults![0].returnValues[1].bcs));
+		const stakeRequired = Number(bcs.U64.parse(res.commandResults![0].returnValues[2].bcs));
+
+		return {
+			takerFee: Number(takerFee / FLOAT_SCALAR),
+			makerFee: Number(makerFee / FLOAT_SCALAR),
+			stakeRequired: Number(stakeRequired / DEEP_SCALAR),
+		};
+	}
+
+	async poolBookParams(poolKey: string): Promise<PoolBookParams> {
+		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.poolBookParams(poolKey));
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const tickSize = Number(bcs.U64.parse(res.commandResults![0].returnValues[0].bcs));
+		const lotSize = Number(bcs.U64.parse(res.commandResults![0].returnValues[1].bcs));
+		const minSize = Number(bcs.U64.parse(res.commandResults![0].returnValues[2].bcs));
+
+		return {
+			tickSize: Number((tickSize * baseScalar) / quoteScalar / FLOAT_SCALAR),
+			lotSize: Number(lotSize / baseScalar),
+			minSize: Number(minSize / baseScalar),
+		};
+	}
+
+	async stablePool(poolKey: string): Promise<boolean> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.deepBook.stablePool(poolKey));
+
+		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);
+	}
+
+	async registeredPool(poolKey: string): Promise<boolean> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.deepBook.registeredPool(poolKey));
+
+		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);
+	}
+
+	async poolTradeParamsNext(poolKey: string): Promise<PoolTradeParams> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.deepBook.poolTradeParamsNext(poolKey));
+
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const takerFee = Number(bcs.U64.parse(res.commandResults![0].returnValues[0].bcs));
+		const makerFee = Number(bcs.U64.parse(res.commandResults![0].returnValues[1].bcs));
+		const stakeRequired = Number(bcs.U64.parse(res.commandResults![0].returnValues[2].bcs));
+
+		return {
+			takerFee: takerFee / FLOAT_SCALAR,
+			makerFee: makerFee / FLOAT_SCALAR,
+			stakeRequired: stakeRequired / DEEP_SCALAR,
+		};
+	}
+
+	async quorum(poolKey: string): Promise<number> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.deepBook.quorum(poolKey));
+
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const bytes = res.commandResults![0].returnValues[0].bcs;
+		const quorum = Number(bcs.U64.parse(bytes));
+		return quorum / DEEP_SCALAR;
+	}
+
+	async poolId(poolKey: string): Promise<string> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.deepBook.poolId(poolKey));
+
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const bytes = res.commandResults![0].returnValues[0].bcs;
+		return normalizeHaneulAddress(bcs.Address.parse(bytes));
+	}
+
+	async canPlaceLimitOrder(params: CanPlaceLimitOrderParams): Promise<boolean> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.deepBook.canPlaceLimitOrder(params));
+
+		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);
+	}
+
+	async canPlaceMarketOrder(params: CanPlaceMarketOrderParams): Promise<boolean> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.deepBook.canPlaceMarketOrder(params));
+
+		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);
+	}
+
+	async checkMarketOrderParams(poolKey: string, quantity: number | bigint): Promise<boolean> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.deepBook.checkMarketOrderParams(poolKey, quantity));
+
+		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);
+	}
+
+	async checkLimitOrderParams(
+		poolKey: string,
+		price: number | bigint,
+		quantity: number | bigint,
+		expireTimestamp: number,
+	): Promise<boolean> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.deepBook.checkLimitOrderParams(poolKey, price, quantity, expireTimestamp));
+
+		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);
+	}
+}