@haneullabs/deepbook-v3 0.1.0 → 1.0.11

package/dist/client.mjs

@@ -0,0 +1,2293 @@
+import { VecSet } from "./contracts/deepbook/deps/haneul/vec_set.mjs";
+import { Account } from "./contracts/deepbook/account.mjs";
+import { OrderDeepPrice } from "./contracts/deepbook/deep_price.mjs";
+import { Order } from "./contracts/deepbook/order.mjs";
+import "./types/bcs.mjs";
+import { BalanceManagerContract } from "./transactions/balanceManager.mjs";
+import { DEEP_SCALAR, DeepBookConfig, FLOAT_SCALAR, PRICE_INFO_OBJECT_MAX_AGE_MS } from "./utils/config.mjs";
+import { DeepBookContract } from "./transactions/deepbook.mjs";
+import { DeepBookAdminContract } from "./transactions/deepbookAdmin.mjs";
+import { FlashLoanContract } from "./transactions/flashLoans.mjs";
+import { GovernanceContract } from "./transactions/governance.mjs";
+import { MarginAdminContract } from "./transactions/marginAdmin.mjs";
+import { MarginMaintainerContract } from "./transactions/marginMaintainer.mjs";
+import { MarginPoolContract } from "./transactions/marginPool.mjs";
+import { MarginManagerContract } from "./transactions/marginManager.mjs";
+import { MarginRegistryContract } from "./transactions/marginRegistry.mjs";
+import { MarginLiquidationsContract } from "./transactions/marginLiquidations.mjs";
+import { HaneulPriceServiceConnection, HaneulPythClient } from "./pyth/pyth.mjs";
+import { PriceInfoObject } from "./contracts/pyth/price_info.mjs";
+import { PoolProxyContract } from "./transactions/poolProxy.mjs";
+import { MarginTPSLContract } from "./transactions/marginTPSL.mjs";
+import { bcs } from "@haneullabs/haneul/bcs";
+import { normalizeHaneulAddress } from "@haneullabs/haneul/utils";
+import { Transaction } from "@haneullabs/haneul/transactions";
+
+//#region src/client.ts
+function deepbook({ name = "deepbook", ...options }) {
+	return {
+		name,
+		register: (client) => {
+			return new DeepBookClient({
+				client,
+				network: client.network,
+				...options
+			});
+		}
+	};
+}
+/**
+* DeepBookClient class for managing DeepBook operations.
+*/
+var DeepBookClient = class {
+	#client;
+	#config;
+	#address;
+	/**
+	* Creates a new DeepBookClient instance
+	*/
+	constructor({ client, address, network, balanceManagers, marginManagers, coins, pools, adminCap, marginAdminCap, marginMaintainerCap }) {
+		this.#client = client;
+		this.#address = normalizeHaneulAddress(address);
+		this.#config = new DeepBookConfig({
+			address: this.#address,
+			network,
+			balanceManagers,
+			marginManagers,
+			coins,
+			pools,
+			adminCap,
+			marginAdminCap,
+			marginMaintainerCap
+		});
+		this.balanceManager = new BalanceManagerContract(this.#config);
+		this.deepBook = new DeepBookContract(this.#config);
+		this.deepBookAdmin = new DeepBookAdminContract(this.#config);
+		this.flashLoans = new FlashLoanContract(this.#config);
+		this.governance = new GovernanceContract(this.#config);
+		this.marginAdmin = new MarginAdminContract(this.#config);
+		this.marginMaintainer = new MarginMaintainerContract(this.#config);
+		this.marginPool = new MarginPoolContract(this.#config);
+		this.marginManager = new MarginManagerContract(this.#config);
+		this.marginRegistry = new MarginRegistryContract(this.#config);
+		this.marginLiquidations = new MarginLiquidationsContract(this.#config);
+		this.poolProxy = new PoolProxyContract(this.#config);
+		this.marginTPSL = new MarginTPSLContract(this.#config);
+	}
+	/**
+	* @description Check the balance of a balance manager for a specific coin
+	* @param {string} managerKey Key of the balance manager
+	* @param {string} coinKey Key of the coin
+	* @returns {Promise<{ coinType: string, balance: number }>} An object with coin type and balance
+	*/
+	async checkManagerBalance(managerKey, coinKey) {
+		const tx = new Transaction();
+		const coin = this.#config.getCoin(coinKey);
+		tx.add(this.balanceManager.checkManagerBalance(managerKey, coinKey));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		const parsed_balance = bcs.U64.parse(bytes);
+		const adjusted_balance = Number(parsed_balance) / coin.scalar;
+		return {
+			coinType: coin.type,
+			balance: Number(adjusted_balance.toFixed(9))
+		};
+	}
+	/**
+	* @description Check the balance of a BalanceManager by its address directly
+	* @param {string} managerAddress The on-chain address of the BalanceManager
+	* @param {string} coinKey Key of the coin
+	* @returns {Promise<{ coinType: string, balance: number }>} An object with coin type and balance
+	*/
+	async checkManagerBalanceWithAddress(managerAddress, coinKey) {
+		const tx = new Transaction();
+		const coin = this.#config.getCoin(coinKey);
+		tx.moveCall({
+			target: `${this.#config.DEEPBOOK_PACKAGE_ID}::balance_manager::balance`,
+			arguments: [tx.object(managerAddress)],
+			typeArguments: [coin.type]
+		});
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		const parsed_balance = bcs.U64.parse(bytes);
+		const adjusted_balance = Number(parsed_balance) / coin.scalar;
+		return {
+			coinType: coin.type,
+			balance: Number(adjusted_balance.toFixed(9))
+		};
+	}
+	/**
+	* @description Check multiple coin balances for multiple balance managers by address in a single dry run call
+	* @param {string[]} managerAddresses The on-chain addresses of the BalanceManagers
+	* @param {string[]} coinKeys Keys of the coins to check balances for
+	* @returns {Promise<Record<string, Record<string, number>>>} Object keyed by manager address, mapping coinType to balance
+	*/
+	async checkManagerBalancesWithAddress(managerAddresses, coinKeys) {
+		if (managerAddresses.length === 0 || coinKeys.length === 0) return {};
+		const tx = new Transaction();
+		const coins = coinKeys.map((coinKey) => this.#config.getCoin(coinKey));
+		for (const managerAddress of managerAddresses) for (const coin of coins) tx.moveCall({
+			target: `${this.#config.DEEPBOOK_PACKAGE_ID}::balance_manager::balance`,
+			arguments: [tx.object(managerAddress)],
+			typeArguments: [coin.type]
+		});
+		const res = await this.#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 = {};
+		for (let m = 0; m < managerAddresses.length; m++) {
+			const managerAddress = managerAddresses[m];
+			const managerBalances = {};
+			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;
+	}
+	/**
+	* @description Check if a pool is whitelisted
+	* @param {string} poolKey Key of the pool
+	* @returns {Promise<boolean>} Boolean indicating if the pool is whitelisted
+	*/
+	async whitelisted(poolKey) {
+		const tx = new Transaction();
+		tx.add(this.deepBook.whitelisted(poolKey));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return bcs.Bool.parse(bytes);
+	}
+	/**
+	* @description Get the quote quantity out for a given base quantity
+	* @param {string} poolKey Key of the pool
+	* @param {number} baseQuantity Base quantity to convert
+	* @returns {Promise<{ baseQuantity: number, baseOut: number, quoteOut: number, deepRequired: number }>}
+	* An object with base quantity, base out, quote out, and deep required for the dry run
+	*/
+	async getQuoteQuantityOut(poolKey, baseQuantity) {
+		const tx = new Transaction();
+		const pool = this.#config.getPool(poolKey);
+		const baseScalar = this.#config.getCoin(pool.baseCoin).scalar;
+		const quoteScalar = this.#config.getCoin(pool.quoteCoin).scalar;
+		tx.add(this.deepBook.getQuoteQuantityOut(poolKey, baseQuantity));
+		const res = await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		});
+		const baseOut = Number(bcs.U64.parse(res.commandResults[0].returnValues[0].bcs));
+		const quoteOut = Number(bcs.U64.parse(res.commandResults[0].returnValues[1].bcs));
+		const deepRequired = Number(bcs.U64.parse(res.commandResults[0].returnValues[2].bcs));
+		return {
+			baseQuantity,
+			baseOut: Number((baseOut / baseScalar).toFixed(9)),
+			quoteOut: Number((quoteOut / quoteScalar).toFixed(9)),
+			deepRequired: Number((deepRequired / DEEP_SCALAR).toFixed(9))
+		};
+	}
+	/**
+	* @description Get the base quantity out for a given quote quantity
+	* @param {string} poolKey Key of the pool
+	* @param {number} quoteQuantity Quote quantity to convert
+	* @returns {Promise<{ quoteQuantity: number, baseOut: number, quoteOut: number, deepRequired: number }>}
+	* An object with quote quantity, base out, quote out, and deep required for the dry run
+	*/
+	async getBaseQuantityOut(poolKey, quoteQuantity) {
+		const tx = new Transaction();
+		const pool = this.#config.getPool(poolKey);
+		const baseScalar = this.#config.getCoin(pool.baseCoin).scalar;
+		const quoteScalar = this.#config.getCoin(pool.quoteCoin).scalar;
+		tx.add(this.deepBook.getBaseQuantityOut(poolKey, quoteQuantity));
+		const res = await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		});
+		const baseOut = Number(bcs.U64.parse(res.commandResults[0].returnValues[0].bcs));
+		const quoteOut = Number(bcs.U64.parse(res.commandResults[0].returnValues[1].bcs));
+		const deepRequired = Number(bcs.U64.parse(res.commandResults[0].returnValues[2].bcs));
+		return {
+			quoteQuantity,
+			baseOut: Number((baseOut / baseScalar).toFixed(9)),
+			quoteOut: Number((quoteOut / quoteScalar).toFixed(9)),
+			deepRequired: Number((deepRequired / DEEP_SCALAR).toFixed(9))
+		};
+	}
+	/**
+	* @description Get the output quantities for given base and quote quantities. Only one quantity can be non-zero
+	* @param {string} poolKey Key of the pool
+	* @param {number} baseQuantity Base quantity to convert
+	* @param {number} quoteQuantity Quote quantity to convert
+	* @returns {Promise<{ baseQuantity: number, quoteQuantity: number, baseOut: number, quoteOut: number, deepRequired: number }>}
+	* An object with base quantity, quote quantity, base out, quote out, and deep required for the dry run
+	*/
+	async getQuantityOut(poolKey, baseQuantity, quoteQuantity) {
+		const tx = new Transaction();
+		const pool = this.#config.getPool(poolKey);
+		const baseScalar = this.#config.getCoin(pool.baseCoin).scalar;
+		const quoteScalar = this.#config.getCoin(pool.quoteCoin).scalar;
+		tx.add(this.deepBook.getQuantityOut(poolKey, baseQuantity, quoteQuantity));
+		const res = await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		});
+		const baseOut = Number(bcs.U64.parse(res.commandResults[0].returnValues[0].bcs));
+		const quoteOut = Number(bcs.U64.parse(res.commandResults[0].returnValues[1].bcs));
+		const deepRequired = Number(bcs.U64.parse(res.commandResults[0].returnValues[2].bcs));
+		return {
+			baseQuantity,
+			quoteQuantity,
+			baseOut: Number((baseOut / baseScalar).toFixed(9)),
+			quoteOut: Number((quoteOut / quoteScalar).toFixed(9)),
+			deepRequired: Number((deepRequired / DEEP_SCALAR).toFixed(9))
+		};
+	}
+	/**
+	* @description Get open orders for a balance manager in a pool
+	* @param {string} poolKey Key of the pool
+	* @param {string} managerKey Key of the balance manager
+	* @returns {Promise<Array>} An array of open order IDs
+	*/
+	async accountOpenOrders(poolKey, managerKey) {
+		const tx = new Transaction();
+		tx.add(this.deepBook.accountOpenOrders(poolKey, managerKey));
+		const order_ids = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return VecSet(bcs.u128()).parse(new Uint8Array(order_ids)).contents;
+	}
+	/**
+	* @description Get the order information for a specific order in a pool
+	* @param {string} poolKey Key of the pool
+	* @param {string} orderId Order ID
+	* @returns {Promise<Object>} A promise that resolves to an object containing the order information
+	*/
+	async getOrder(poolKey, orderId) {
+		const tx = new Transaction();
+		tx.add(this.deepBook.getOrder(poolKey, orderId));
+		const res = await this.#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;
+		}
+	}
+	/**
+	* @description Get the order information for a specific order in a pool, with normalized price
+	* @param {string} poolKey Key of the pool
+	* @param {string} orderId Order ID
+	* @returns {Promise<Object>} A promise that resolves to an object containing the order information with normalized price
+	*/
+	async getOrderNormalized(poolKey, orderId) {
+		const tx = new Transaction();
+		tx.add(this.deepBook.getOrder(poolKey, orderId));
+		const res = await this.#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.#config.getCoin(this.#config.getPool(poolKey).baseCoin);
+			const quoteCoin = this.#config.getCoin(this.#config.getPool(poolKey).quoteCoin);
+			const { isBid, price: rawPrice } = this.decodeOrderId(BigInt(orderInfo.order_id));
+			const normalizedPrice = rawPrice * baseCoin.scalar / quoteCoin.scalar / FLOAT_SCALAR;
+			return {
+				...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)
+			};
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* @description Retrieves information for multiple specific orders in a pool.
+	* @param {string} poolKey - The key identifying the pool from which to retrieve order information.
+	* @param {string[]} orderIds - List of order IDs to retrieve information for.
+	* @returns {Promise<Object[] | null>} A promise that resolves to an array of order objects, each containing details such as
+	* balance manager ID, order ID, client order ID, quantity, filled quantity, fee information, order price, epoch, status,
+	* and expiration timestamp. Returns `null` if the retrieval fails.
+	*/
+	async getOrders(poolKey, orderIds) {
+		const tx = new Transaction();
+		tx.add(this.deepBook.getOrders(poolKey, orderIds));
+		const res = await this.#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;
+		}
+	}
+	/**
+	* @description Get level 2 order book specifying range of price
+	* @param {string} poolKey Key of the pool
+	* @param {number} priceLow Lower bound of the price range
+	* @param {number} priceHigh Upper bound of the price range
+	* @param {boolean} isBid Whether to get bid or ask orders
+	* @returns {Promise<{ prices: Array<number>, quantities: Array<number> }>}
+	* An object with arrays of prices and quantities
+	*/
+	async getLevel2Range(poolKey, priceLow, priceHigh, isBid) {
+		const tx = new Transaction();
+		const pool = this.#config.getPool(poolKey);
+		const baseCoin = this.#config.getCoin(pool.baseCoin);
+		const quoteCoin = this.#config.getCoin(pool.quoteCoin);
+		tx.add(this.deepBook.getLevel2Range(poolKey, priceLow, priceHigh, isBid));
+		const res = await this.#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)))
+		};
+	}
+	/**
+	* @description Get level 2 order book ticks from mid-price for a pool
+	* @param {string} poolKey Key of the pool
+	* @param {number} ticks Number of ticks from mid-price
+	* @returns {Promise<{ bid_prices: Array<number>, bid_quantities: Array<number>, ask_prices: Array<number>, ask_quantities: Array<number> }>}
+	* An object with arrays of prices and quantities
+	*/
+	async getLevel2TicksFromMid(poolKey, ticks) {
+		const tx = new Transaction();
+		const pool = this.#config.getPool(poolKey);
+		const baseCoin = this.#config.getCoin(pool.baseCoin);
+		const quoteCoin = this.#config.getCoin(pool.quoteCoin);
+		tx.add(this.deepBook.getLevel2TicksFromMid(poolKey, ticks));
+		const res = await this.#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)))
+		};
+	}
+	/**
+	* @description Get the vault balances for a pool
+	* @param {string} poolKey Key of the pool
+	* @returns {Promise<{ base: number, quote: number, deep: number }>}
+	* An object with base, quote, and deep balances in the vault
+	*/
+	async vaultBalances(poolKey) {
+		const tx = new Transaction();
+		const pool = this.#config.getPool(poolKey);
+		const baseScalar = this.#config.getCoin(pool.baseCoin).scalar;
+		const quoteScalar = this.#config.getCoin(pool.quoteCoin).scalar;
+		tx.add(this.deepBook.vaultBalances(poolKey));
+		const res = await this.#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))
+		};
+	}
+	/**
+	* @description Get the pool ID by asset types
+	* @param {string} baseType Type of the base asset
+	* @param {string} quoteType Type of the quote asset
+	* @returns {Promise<string>} The address of the pool
+	*/
+	async getPoolIdByAssets(baseType, quoteType) {
+		const tx = new Transaction();
+		tx.add(this.deepBook.getPoolIdByAssets(baseType, quoteType));
+		const res = await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		});
+		return bcs.Address.parse(res.commandResults[0].returnValues[0].bcs);
+	}
+	/**
+	* @description Get the mid price for a pool
+	* @param {string} poolKey Key of the pool
+	* @returns {Promise<number>} The mid price
+	*/
+	async midPrice(poolKey) {
+		const tx = new Transaction();
+		const pool = this.#config.getPool(poolKey);
+		tx.add(this.deepBook.midPrice(poolKey));
+		const baseCoin = this.#config.getCoin(pool.baseCoin);
+		const quoteCoin = this.#config.getCoin(pool.quoteCoin);
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		const adjusted_mid_price = Number(bcs.U64.parse(bytes)) * baseCoin.scalar / quoteCoin.scalar / FLOAT_SCALAR;
+		return Number(adjusted_mid_price.toFixed(9));
+	}
+	/**
+	* @description Get the trade parameters for a given pool, including taker fee, maker fee, and stake required.
+	* @param {string} poolKey Key of the pool
+	* @returns {Promise<{ takerFee: number, makerFee: number, stakeRequired: number }>}
+	*/
+	async poolTradeParams(poolKey) {
+		const tx = new Transaction();
+		tx.add(this.deepBook.poolTradeParams(poolKey));
+		const res = await this.#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)
+		};
+	}
+	/**
+	* @description Get the trade parameters for a given pool, including tick size, lot size, and min size.
+	* @param {string} poolKey Key of the pool
+	* @returns {Promise<{ tickSize: number, lotSize: number, minSize: number }>}
+	*/
+	async poolBookParams(poolKey) {
+		const tx = new Transaction();
+		const pool = this.#config.getPool(poolKey);
+		const baseScalar = this.#config.getCoin(pool.baseCoin).scalar;
+		const quoteScalar = this.#config.getCoin(pool.quoteCoin).scalar;
+		tx.add(this.deepBook.poolBookParams(poolKey));
+		const res = await this.#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)
+		};
+	}
+	/**
+	* @description Get the account information for a given pool and balance manager
+	* @param {string} poolKey Key of the pool
+	* @param {string} managerKey The key of the BalanceManager
+	* @returns {Promise<Object>} A promise that resolves to an object containing the account information
+	*/
+	async account(poolKey, managerKey) {
+		const tx = new Transaction();
+		const pool = this.#config.getPool(poolKey);
+		const baseScalar = this.#config.getCoin(pool.baseCoin).scalar;
+		const quoteScalar = this.#config.getCoin(pool.quoteCoin).scalar;
+		tx.add(this.deepBook.account(poolKey, managerKey));
+		const accountInformation = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).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
+			}
+		};
+	}
+	/**
+	* @description Get the locked balances for a pool and balance manager
+	* @param {string} poolKey Key of the pool
+	* @param {string} managerKey The key of the BalanceManager
+	* @returns {Promise<{ base: number, quote: number, deep: number }>}
+	* An object with base, quote, and deep locked for the balance manager in the pool
+	*/
+	async lockedBalance(poolKey, balanceManagerKey) {
+		const tx = new Transaction();
+		const pool = this.#config.getPool(poolKey);
+		const baseScalar = this.#config.getCoin(pool.baseCoin).scalar;
+		const quoteScalar = this.#config.getCoin(pool.quoteCoin).scalar;
+		tx.add(this.deepBook.lockedBalance(poolKey, balanceManagerKey));
+		const res = await this.#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))
+		};
+	}
+	/**
+	* @description Get the DEEP price conversion for a pool
+	* @param {string} poolKey Key of the pool
+	* @returns {Promise<{ asset_is_base: bool, deep_per_quote: number }>} Deep price conversion
+	*/
+	async getPoolDeepPrice(poolKey) {
+		const tx = new Transaction();
+		const pool = this.#config.getPool(poolKey);
+		tx.add(this.deepBook.getPoolDeepPrice(poolKey));
+		const baseCoin = this.#config.getCoin(pool.baseCoin);
+		const quoteCoin = this.#config.getCoin(pool.quoteCoin);
+		const deepCoin = this.#config.getCoin("DEEP");
+		const poolDeepPriceBytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).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
+		};
+	}
+	/**
+	* @description Decode the order ID to get bid/ask status, price, and orderId
+	* @param {bigint} encodedOrderId Encoded order ID
+	* @returns {Object} Object containing isBid, price, and orderId
+	*/
+	decodeOrderId(encodedOrderId) {
+		return {
+			isBid: encodedOrderId >> 127n === 0n,
+			price: Number(encodedOrderId >> 64n & (1n << 63n) - 1n),
+			orderId: Number(encodedOrderId & (1n << 64n) - 1n)
+		};
+	}
+	/**
+	* @description Get all balance manager IDs for a given owner
+	* @param {string} owner The owner address to get balance manager IDs for
+	* @returns {Promise<string[]>} Array of balance manager ID strings
+	*/
+	async getBalanceManagerIds(owner) {
+		const tx = new Transaction();
+		tx.add(this.deepBook.getBalanceManagerIds(owner));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return bcs.vector(bcs.Address).parse(bytes).map((id) => normalizeHaneulAddress(id));
+	}
+	/**
+	* @description Get the owner of the referral (DeepBookPoolReferral)
+	* @param {string} referral The ID of the referral to get the owner of
+	* @returns {Promise<string>} The owner of the referral
+	*/
+	async balanceManagerReferralOwner(referral) {
+		const tx = new Transaction();
+		tx.add(this.balanceManager.balanceManagerReferralOwner(referral));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return bcs.Address.parse(bytes);
+	}
+	/**
+	* @description Get the referral balances for a pool and referral (DeepBookPoolReferral)
+	* @param {string} poolKey Key of the pool
+	* @param {string} referral The referral ID to get balances for
+	* @returns {Promise<{ base: number, quote: number, deep: number }>} Object with base, quote, and deep balances
+	*/
+	async getPoolReferralBalances(poolKey, referral) {
+		const tx = new Transaction();
+		const pool = this.#config.getPool(poolKey);
+		const baseScalar = this.#config.getCoin(pool.baseCoin).scalar;
+		const quoteScalar = this.#config.getCoin(pool.quoteCoin).scalar;
+		tx.add(this.deepBook.getPoolReferralBalances(poolKey, referral));
+		const res = await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		});
+		const baseBytes = res.commandResults[0].returnValues[0].bcs;
+		const quoteBytes = res.commandResults[0].returnValues[1].bcs;
+		const deepBytes = res.commandResults[0].returnValues[2].bcs;
+		const baseBalance = Number(bcs.U64.parse(baseBytes));
+		const quoteBalance = Number(bcs.U64.parse(quoteBytes));
+		const deepBalance = Number(bcs.U64.parse(deepBytes));
+		return {
+			base: baseBalance / baseScalar,
+			quote: quoteBalance / quoteScalar,
+			deep: deepBalance / DEEP_SCALAR
+		};
+	}
+	/**
+	* @description Get the pool ID associated with a referral (DeepBookPoolReferral)
+	* @param {string} referral The referral (DeepBookPoolReferral) to get the pool ID for
+	* @returns {Promise<string>} The pool ID
+	*/
+	async balanceManagerReferralPoolId(referral) {
+		const tx = new Transaction();
+		tx.add(this.balanceManager.balanceManagerReferralPoolId(referral));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return normalizeHaneulAddress(bcs.Address.parse(bytes));
+	}
+	/**
+	* @description Get the multiplier for a referral (DeepBookPoolReferral)
+	* @param {string} poolKey Key of the pool
+	* @param {string} referral The referral (DeepBookPoolReferral) to get the multiplier for
+	* @returns {Promise<number>} The multiplier value
+	*/
+	async poolReferralMultiplier(poolKey, referral) {
+		const tx = new Transaction();
+		tx.add(this.deepBook.poolReferralMultiplier(poolKey, referral));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return Number(bcs.U64.parse(bytes)) / FLOAT_SCALAR;
+	}
+	/**
+	* @description Get the referral ID from a balance manager for a specific pool
+	* @param {string} managerKey Key of the balance manager
+	* @param {string} poolKey Key of the pool to get the referral for
+	* @returns {Promise<string | null>} The referral ID or null if not set
+	*/
+	async getBalanceManagerReferralId(managerKey, poolKey) {
+		const tx = new Transaction();
+		tx.add(this.balanceManager.getBalanceManagerReferralId(managerKey, poolKey));
+		const res = await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		});
+		try {
+			const bytes = res.commandResults[0].returnValues[0].bcs;
+			const optionId = bcs.option(bcs.Address).parse(bytes);
+			if (optionId === null) return null;
+			return normalizeHaneulAddress(optionId);
+		} catch {
+			return null;
+		}
+	}
+	async getPriceInfoObject(tx, coinKey) {
+		const currentTime = Date.now();
+		const priceInfoObjectAge = await this.getPriceInfoObjectAge(coinKey);
+		if (priceInfoObjectAge && currentTime - priceInfoObjectAge * 1e3 < PRICE_INFO_OBJECT_MAX_AGE_MS) return await this.#config.getCoin(coinKey).priceInfoObjectId;
+		const connection = new HaneulPriceServiceConnection(this.#config.network === "testnet" ? "https://hermes-beta.pyth.network" : "https://hermes.pyth.network");
+		const priceIDs = [this.#config.getCoin(coinKey).feed];
+		const priceUpdateData = await connection.getPriceFeedsUpdateData(priceIDs);
+		const wormholeStateId = this.#config.pyth.wormholeStateId;
+		const pythStateId = this.#config.pyth.pythStateId;
+		return (await new HaneulPythClient(this.#client, pythStateId, wormholeStateId).updatePriceFeeds(tx, priceUpdateData, priceIDs))[0];
+	}
+	/**
+	* @description Batch update price info objects for multiple coins. Only updates stale feeds.
+	* This is more efficient than calling getPriceInfoObject multiple times as it:
+	* 1. Batch fetches all price info object ages in one RPC call
+	* 2. Fetches all stale price updates from Pyth in a single API call
+	* @param {Transaction} tx Transaction to add price update commands to
+	* @param {string[]} coinKeys Array of coin keys to update prices for
+	* @returns {Promise<Record<string, string>>} Map of coinKey -> priceInfoObjectId
+	*/
+	async getPriceInfoObjects(tx, coinKeys) {
+		if (coinKeys.length === 0) return {};
+		const currentTime = Date.now();
+		const coinToObjectId = {};
+		const objectIds = [];
+		for (const coinKey of coinKeys) {
+			const priceInfoObjectId = this.#config.getCoin(coinKey).priceInfoObjectId;
+			coinToObjectId[coinKey] = priceInfoObjectId;
+			objectIds.push(priceInfoObjectId);
+		}
+		const res = await this.#client.core.getObjects({
+			objectIds,
+			include: { content: true }
+		});
+		const staleCoinKeys = [];
+		const result = {};
+		for (let i = 0; i < coinKeys.length; i++) {
+			const coinKey = coinKeys[i];
+			const obj = res.objects[i];
+			if (obj instanceof Error || !obj?.content) {
+				staleCoinKeys.push(coinKey);
+				continue;
+			}
+			const priceInfoObject = PriceInfoObject.parse(obj.content);
+			if (currentTime - Number(priceInfoObject.price_info.arrival_time) * 1e3 >= PRICE_INFO_OBJECT_MAX_AGE_MS) staleCoinKeys.push(coinKey);
+			else result[coinKey] = coinToObjectId[coinKey];
+		}
+		if (staleCoinKeys.length === 0) return result;
+		const staleFeedIds = [];
+		const feedIdToCoinKey = {};
+		for (const coinKey of staleCoinKeys) {
+			const feedId = this.#config.getCoin(coinKey).feed;
+			staleFeedIds.push(feedId);
+			feedIdToCoinKey[feedId] = coinKey;
+		}
+		const priceUpdateData = await new HaneulPriceServiceConnection(this.#config.network === "testnet" ? "https://hermes-beta.pyth.network" : "https://hermes.pyth.network").getPriceFeedsUpdateData(staleFeedIds);
+		const wormholeStateId = this.#config.pyth.wormholeStateId;
+		const pythStateId = this.#config.pyth.pythStateId;
+		const updatedObjectIds = await new HaneulPythClient(this.#client, pythStateId, wormholeStateId).updatePriceFeeds(tx, priceUpdateData, staleFeedIds);
+		for (let i = 0; i < staleFeedIds.length; i++) {
+			const coinKey = feedIdToCoinKey[staleFeedIds[i]];
+			result[coinKey] = updatedObjectIds[i];
+		}
+		return result;
+	}
+	/**
+	* @description Get the age of the price info object for a specific coin
+	* @param {string} coinKey Key of the coin
+	* @returns {Promise<number>} The arrival time of the price info object
+	*/
+	async getPriceInfoObjectAge(coinKey) {
+		const priceInfoObjectId = this.#config.getCoin(coinKey).priceInfoObjectId;
+		const res = await this.#client.core.getObject({
+			objectId: priceInfoObjectId,
+			include: { content: true }
+		});
+		if (!res.object?.content) throw new Error(`Price info object not found for ${coinKey}`);
+		const priceInfoObject = PriceInfoObject.parse(res.object.content);
+		return Number(priceInfoObject.price_info.arrival_time);
+	}
+	/**
+	* @description Get the margin pool ID
+	* @param {string} coinKey The key to identify the margin pool
+	* @returns {Promise<string>} The margin pool ID
+	*/
+	async getMarginPoolId(coinKey) {
+		const tx = new Transaction();
+		tx.add(this.marginPool.getId(coinKey));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return bcs.Address.parse(bytes);
+	}
+	/**
+	* @description Check if a deepbook pool is allowed for borrowing from margin pool
+	* @param {string} coinKey The key to identify the margin pool
+	* @param {string} deepbookPoolId The ID of the deepbook pool
+	* @returns {Promise<boolean>} Whether the deepbook pool is allowed
+	*/
+	async isDeepbookPoolAllowed(coinKey, deepbookPoolId) {
+		const tx = new Transaction();
+		tx.add(this.marginPool.deepbookPoolAllowed(coinKey, deepbookPoolId));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return bcs.bool().parse(bytes);
+	}
+	/**
+	* @description Get the total supply amount in the margin pool
+	* @param {string} coinKey The key to identify the margin pool
+	* @param {number} decimals Number of decimal places to show (default: 6)
+	* @returns {Promise<string>} The total supply amount as a string
+	*/
+	async getMarginPoolTotalSupply(coinKey, decimals = 6) {
+		const tx = new Transaction();
+		tx.add(this.marginPool.totalSupply(coinKey));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		const rawAmount = BigInt(bcs.U64.parse(bytes));
+		const coin = this.#config.getCoin(coinKey);
+		return this.#formatTokenAmount(rawAmount, coin.scalar, decimals);
+	}
+	/**
+	* @description Get the total supply shares in the margin pool
+	* @param {string} coinKey The key to identify the margin pool
+	* @param {number} decimals Number of decimal places to show (default: 6)
+	* @returns {Promise<string>} The total supply shares as a string
+	*/
+	async getMarginPoolSupplyShares(coinKey, decimals = 6) {
+		const tx = new Transaction();
+		tx.add(this.marginPool.supplyShares(coinKey));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		const rawShares = BigInt(bcs.U64.parse(bytes));
+		const coin = this.#config.getCoin(coinKey);
+		return this.#formatTokenAmount(rawShares, coin.scalar, decimals);
+	}
+	/**
+	* @description Get the total borrow amount in the margin pool
+	* @param {string} coinKey The key to identify the margin pool
+	* @param {number} decimals Number of decimal places to show (default: 6)
+	* @returns {Promise<string>} The total borrow amount as a string
+	*/
+	async getMarginPoolTotalBorrow(coinKey, decimals = 6) {
+		const tx = new Transaction();
+		tx.add(this.marginPool.totalBorrow(coinKey));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		const rawAmount = BigInt(bcs.U64.parse(bytes));
+		const coin = this.#config.getCoin(coinKey);
+		return this.#formatTokenAmount(rawAmount, coin.scalar, decimals);
+	}
+	/**
+	* @description Get the total borrow shares in the margin pool
+	* @param {string} coinKey The key to identify the margin pool
+	* @param {number} decimals Number of decimal places to show (default: 6)
+	* @returns {Promise<string>} The total borrow shares as a string
+	*/
+	async getMarginPoolBorrowShares(coinKey, decimals = 6) {
+		const tx = new Transaction();
+		tx.add(this.marginPool.borrowShares(coinKey));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		const rawShares = BigInt(bcs.U64.parse(bytes));
+		const coin = this.#config.getCoin(coinKey);
+		return this.#formatTokenAmount(rawShares, coin.scalar, decimals);
+	}
+	/**
+	* @description Get the last update timestamp of the margin pool
+	* @param {string} coinKey The key to identify the margin pool
+	* @returns {Promise<number>} The last update timestamp in milliseconds
+	*/
+	async getMarginPoolLastUpdateTimestamp(coinKey) {
+		const tx = new Transaction();
+		tx.add(this.marginPool.lastUpdateTimestamp(coinKey));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return Number(bcs.U64.parse(bytes));
+	}
+	/**
+	* @description Get the supply cap of the margin pool
+	* @param {string} coinKey The key to identify the margin pool
+	* @param {number} decimals Number of decimal places to show (default: 6)
+	* @returns {Promise<string>} The supply cap as a string
+	*/
+	async getMarginPoolSupplyCap(coinKey, decimals = 6) {
+		const tx = new Transaction();
+		tx.add(this.marginPool.supplyCap(coinKey));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		const rawAmount = BigInt(bcs.U64.parse(bytes));
+		const coin = this.#config.getCoin(coinKey);
+		return this.#formatTokenAmount(rawAmount, coin.scalar, decimals);
+	}
+	/**
+	* @description Get the max utilization rate of the margin pool
+	* @param {string} coinKey The key to identify the margin pool
+	* @returns {Promise<number>} The max utilization rate (as a decimal, e.g., 0.95 for 95%)
+	*/
+	async getMarginPoolMaxUtilizationRate(coinKey) {
+		const tx = new Transaction();
+		tx.add(this.marginPool.maxUtilizationRate(coinKey));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return Number(bcs.U64.parse(bytes)) / FLOAT_SCALAR;
+	}
+	/**
+	* @description Get the protocol spread of the margin pool
+	* @param {string} coinKey The key to identify the margin pool
+	* @returns {Promise<number>} The protocol spread (as a decimal)
+	*/
+	async getMarginPoolProtocolSpread(coinKey) {
+		const tx = new Transaction();
+		tx.add(this.marginPool.protocolSpread(coinKey));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return Number(bcs.U64.parse(bytes)) / FLOAT_SCALAR;
+	}
+	/**
+	* @description Get the minimum borrow amount for the margin pool
+	* @param {string} coinKey The key to identify the margin pool
+	* @param {number} decimals Number of decimal places to show (default: 6)
+	* @returns {Promise<string>} The minimum borrow amount as a string
+	*/
+	async getMarginPoolMinBorrow(coinKey, decimals = 6) {
+		const tx = new Transaction();
+		tx.add(this.marginPool.minBorrow(coinKey));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		const rawAmount = BigInt(bcs.U64.parse(bytes));
+		const coin = this.#config.getCoin(coinKey);
+		return this.#formatTokenAmount(rawAmount, coin.scalar, decimals);
+	}
+	/**
+	* @description Get the current interest rate of the margin pool
+	* @param {string} coinKey The key to identify the margin pool
+	* @returns {Promise<number>} The current interest rate (as a decimal)
+	*/
+	async getMarginPoolInterestRate(coinKey) {
+		const tx = new Transaction();
+		tx.add(this.marginPool.interestRate(coinKey));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return Number(bcs.U64.parse(bytes)) / FLOAT_SCALAR;
+	}
+	/**
+	* @description Get user supply shares for a supplier cap
+	* @param {string} coinKey The key to identify the margin pool
+	* @param {string} supplierCapId The ID of the supplier cap
+	* @param {number} decimals Number of decimal places to show (default: 6)
+	* @returns {Promise<string>} The user's supply shares as a string
+	*/
+	async getUserSupplyShares(coinKey, supplierCapId, decimals = 6) {
+		const tx = new Transaction();
+		tx.add(this.marginPool.userSupplyShares(coinKey, supplierCapId));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		const rawShares = BigInt(bcs.U64.parse(bytes));
+		const coin = this.#config.getCoin(coinKey);
+		return this.#formatTokenAmount(rawShares, coin.scalar, decimals);
+	}
+	/**
+	* @description Get user supply amount for a supplier cap
+	* @param {string} coinKey The key to identify the margin pool
+	* @param {string} supplierCapId The ID of the supplier cap
+	* @param {number} decimals Number of decimal places to show (default: 6)
+	* @returns {Promise<string>} The user's supply amount as a string
+	*/
+	async getUserSupplyAmount(coinKey, supplierCapId, decimals = 6) {
+		const tx = new Transaction();
+		tx.add(this.marginPool.userSupplyAmount(coinKey, supplierCapId));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		const rawAmount = BigInt(bcs.U64.parse(bytes));
+		const coin = this.#config.getCoin(coinKey);
+		return this.#formatTokenAmount(rawAmount, coin.scalar, decimals);
+	}
+	/**
+	* @description Get the owner address of a margin manager
+	* @param {string} marginManagerKey The key to identify the margin manager
+	* @returns {Promise<string>} The owner address
+	*/
+	async getMarginManagerOwner(marginManagerKey) {
+		const manager = this.#config.getMarginManager(marginManagerKey);
+		const tx = new Transaction();
+		tx.add(this.marginManager.ownerByPoolKey(manager.poolKey, manager.address));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return normalizeHaneulAddress(bcs.Address.parse(bytes));
+	}
+	/**
+	* @description Get the DeepBook pool ID associated with a margin manager
+	* @param {string} marginManagerKey The key to identify the margin manager
+	* @returns {Promise<string>} The DeepBook pool ID
+	*/
+	async getMarginManagerDeepbookPool(marginManagerKey) {
+		const manager = this.#config.getMarginManager(marginManagerKey);
+		const tx = new Transaction();
+		tx.add(this.marginManager.deepbookPool(manager.poolKey, manager.address));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return normalizeHaneulAddress(bcs.Address.parse(bytes));
+	}
+	/**
+	* @description Get the margin pool ID (if any) associated with a margin manager
+	* @param {string} marginManagerKey The key to identify the margin manager
+	* @returns {Promise<string | null>} The margin pool ID or null if no active loan
+	*/
+	async getMarginManagerMarginPoolId(marginManagerKey) {
+		const manager = this.#config.getMarginManager(marginManagerKey);
+		const tx = new Transaction();
+		tx.add(this.marginManager.marginPoolId(manager.poolKey, manager.address));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		const option = bcs.option(bcs.Address).parse(bytes);
+		return option ? normalizeHaneulAddress(option) : null;
+	}
+	/**
+	* @description Get borrowed shares for both base and quote assets
+	* @param {string} marginManagerKey The key to identify the margin manager
+	* @returns {Promise<{baseShares: string, quoteShares: string}>} The borrowed shares
+	*/
+	async getMarginManagerBorrowedShares(marginManagerKey) {
+		const manager = this.#config.getMarginManager(marginManagerKey);
+		const tx = new Transaction();
+		tx.add(this.marginManager.borrowedShares(manager.poolKey, manager.address));
+		const res = await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		});
+		const baseBytes = res.commandResults[0].returnValues[0].bcs;
+		const quoteBytes = res.commandResults[0].returnValues[1].bcs;
+		return {
+			baseShares: bcs.U64.parse(baseBytes).toString(),
+			quoteShares: bcs.U64.parse(quoteBytes).toString()
+		};
+	}
+	/**
+	* @description Get borrowed base shares
+	* @param {string} marginManagerKey The key to identify the margin manager
+	* @returns {Promise<string>} The borrowed base shares
+	*/
+	async getMarginManagerBorrowedBaseShares(marginManagerKey) {
+		const manager = this.#config.getMarginManager(marginManagerKey);
+		const tx = new Transaction();
+		tx.add(this.marginManager.borrowedBaseShares(manager.poolKey, manager.address));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return bcs.U64.parse(bytes).toString();
+	}
+	/**
+	* @description Get borrowed quote shares
+	* @param {string} marginManagerKey The key to identify the margin manager
+	* @returns {Promise<string>} The borrowed quote shares
+	*/
+	async getMarginManagerBorrowedQuoteShares(marginManagerKey) {
+		const manager = this.#config.getMarginManager(marginManagerKey);
+		const tx = new Transaction();
+		tx.add(this.marginManager.borrowedQuoteShares(manager.poolKey, manager.address));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return bcs.U64.parse(bytes).toString();
+	}
+	/**
+	* @description Check if margin manager has base asset debt
+	* @param {string} marginManagerKey The key to identify the margin manager
+	* @returns {Promise<boolean>} True if has base debt, false otherwise
+	*/
+	async getMarginManagerHasBaseDebt(marginManagerKey) {
+		const manager = this.#config.getMarginManager(marginManagerKey);
+		const tx = new Transaction();
+		tx.add(this.marginManager.hasBaseDebt(manager.poolKey, manager.address));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return bcs.bool().parse(bytes);
+	}
+	/**
+	* @description Get the balance manager ID for a margin manager
+	* @param {string} marginManagerKey The key to identify the margin manager
+	* @returns {Promise<string>} The balance manager ID
+	*/
+	async getMarginManagerBalanceManagerId(marginManagerKey) {
+		const manager = this.#config.getMarginManager(marginManagerKey);
+		const tx = new Transaction();
+		tx.add(this.marginManager.balanceManager(manager.poolKey, manager.address));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return normalizeHaneulAddress(bcs.Address.parse(bytes));
+	}
+	/**
+	* @description Calculate assets (base and quote) for a margin manager
+	* @param {string} marginManagerKey The key to identify the margin manager
+	* @param {number} decimals Number of decimal places to show (default: 6)
+	* @returns {Promise<{baseAsset: string, quoteAsset: string}>} The base and quote assets
+	*/
+	async getMarginManagerAssets(marginManagerKey, decimals = 6) {
+		const manager = this.#config.getMarginManager(marginManagerKey);
+		const tx = new Transaction();
+		tx.add(this.marginManager.calculateAssets(manager.poolKey, manager.address));
+		const res = await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		});
+		const baseBytes = res.commandResults[0].returnValues[0].bcs;
+		const quoteBytes = res.commandResults[0].returnValues[1].bcs;
+		const pool = this.#config.getPool(manager.poolKey);
+		const baseCoin = this.#config.getCoin(pool.baseCoin);
+		const quoteCoin = this.#config.getCoin(pool.quoteCoin);
+		return {
+			baseAsset: this.#formatTokenAmount(BigInt(bcs.U64.parse(baseBytes)), baseCoin.scalar, decimals),
+			quoteAsset: this.#formatTokenAmount(BigInt(bcs.U64.parse(quoteBytes)), quoteCoin.scalar, decimals)
+		};
+	}
+	/**
+	* @description Calculate debts (base and quote) for a margin manager
+	* NOTE: This function automatically determines whether to use base or quote margin pool
+	* based on hasBaseDebt. You don't need to specify the debt coin type.
+	* @param {string} marginManagerKey The key to identify the margin manager
+	* @param {number} decimals Number of decimal places to show (default: 6)
+	* @returns {Promise<{baseDebt: string, quoteDebt: string}>} The base and quote debts
+	*/
+	async getMarginManagerDebts(marginManagerKey, decimals = 6) {
+		const hasBaseDebt = await this.getMarginManagerHasBaseDebt(marginManagerKey);
+		const manager = this.#config.getMarginManager(marginManagerKey);
+		const pool = this.#config.getPool(manager.poolKey);
+		const debtCoinKey = hasBaseDebt ? pool.baseCoin : pool.quoteCoin;
+		const tx = new Transaction();
+		tx.add(this.marginManager.calculateDebts(manager.poolKey, debtCoinKey, manager.address));
+		const res = await this.#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 || !res.commandResults[0] || !res.commandResults[0].returnValues) throw new Error(`Failed to get margin manager debts: Unknown error`);
+		const baseBytes = res.commandResults[0].returnValues[0].bcs;
+		const quoteBytes = res.commandResults[0].returnValues[1].bcs;
+		const debtCoin = this.#config.getCoin(debtCoinKey);
+		return {
+			baseDebt: this.#formatTokenAmount(BigInt(bcs.U64.parse(baseBytes)), debtCoin.scalar, decimals),
+			quoteDebt: this.#formatTokenAmount(BigInt(bcs.U64.parse(quoteBytes)), debtCoin.scalar, decimals)
+		};
+	}
+	/**
+	* @description Get comprehensive state information for a margin manager
+	* @param {string} marginManagerKey The key to identify the margin manager
+	* @param {number} decimals Number of decimal places to show (default: 6)
+	* @returns {Promise<{
+	*   managerId: string,
+	*   deepbookPoolId: string,
+	*   riskRatio: number,
+	*   baseAsset: string,
+	*   quoteAsset: string,
+	*   baseDebt: string,
+	*   quoteDebt: string,
+	*   basePythPrice: string,
+	*   basePythDecimals: number,
+	*   quotePythPrice: string,
+	*   quotePythDecimals: number
+	* }>} Comprehensive margin manager state
+	*/
+	async getMarginManagerState(marginManagerKey, decimals = 6) {
+		const manager = this.#config.getMarginManager(marginManagerKey);
+		const tx = new Transaction();
+		tx.add(this.marginManager.managerState(manager.poolKey, manager.address));
+		const res = await this.#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 || !res.commandResults[0] || !res.commandResults[0].returnValues) throw new Error(`Failed to get margin manager state: Unknown error`);
+		const pool = this.#config.getPool(manager.poolKey);
+		const baseCoin = this.#config.getCoin(pool.baseCoin);
+		const quoteCoin = this.#config.getCoin(pool.quoteCoin);
+		const managerId = normalizeHaneulAddress(bcs.Address.parse(res.commandResults[0].returnValues[0].bcs));
+		const deepbookPoolId = normalizeHaneulAddress(bcs.Address.parse(res.commandResults[0].returnValues[1].bcs));
+		const riskRatio = Number(bcs.U64.parse(res.commandResults[0].returnValues[2].bcs)) / FLOAT_SCALAR;
+		const baseAsset = this.#formatTokenAmount(BigInt(bcs.U64.parse(res.commandResults[0].returnValues[3].bcs)), baseCoin.scalar, decimals);
+		const quoteAsset = this.#formatTokenAmount(BigInt(bcs.U64.parse(res.commandResults[0].returnValues[4].bcs)), quoteCoin.scalar, decimals);
+		const baseDebt = this.#formatTokenAmount(BigInt(bcs.U64.parse(res.commandResults[0].returnValues[5].bcs)), baseCoin.scalar, decimals);
+		const quoteDebt = this.#formatTokenAmount(BigInt(bcs.U64.parse(res.commandResults[0].returnValues[6].bcs)), quoteCoin.scalar, decimals);
+		const basePythPrice = bcs.U64.parse(res.commandResults[0].returnValues[7].bcs);
+		const basePythDecimals = Number(bcs.u8().parse(new Uint8Array(res.commandResults[0].returnValues[8].bcs)));
+		const quotePythPrice = bcs.U64.parse(res.commandResults[0].returnValues[9].bcs);
+		const quotePythDecimals = Number(bcs.u8().parse(new Uint8Array(res.commandResults[0].returnValues[10].bcs)));
+		const currentPrice = BigInt(bcs.U64.parse(res.commandResults[0].returnValues[11].bcs));
+		const lowestTriggerAbovePrice = BigInt(bcs.U64.parse(res.commandResults[0].returnValues[12].bcs));
+		const highestTriggerBelowPrice = BigInt(bcs.U64.parse(res.commandResults[0].returnValues[13].bcs));
+		return {
+			managerId,
+			deepbookPoolId,
+			riskRatio,
+			baseAsset,
+			quoteAsset,
+			baseDebt,
+			quoteDebt,
+			basePythPrice: basePythPrice.toString(),
+			basePythDecimals,
+			quotePythPrice: quotePythPrice.toString(),
+			quotePythDecimals,
+			currentPrice,
+			lowestTriggerAbovePrice,
+			highestTriggerBelowPrice
+		};
+	}
+	/**
+	* @description Get comprehensive state information for multiple margin managers.
+	* @param {Record<string, string>} marginManagers Map of marginManagerId -> poolKey
+	* @param {number} decimals Number of decimal places for formatting (default: 6)
+	* @returns {Promise<Record<string, {...}>>} Object keyed by managerId with state data
+	*/
+	async getMarginManagerStates(marginManagers, decimals = 6) {
+		const entries = Object.entries(marginManagers);
+		if (entries.length === 0) return {};
+		const tx = new Transaction();
+		for (const [managerId, poolKey] of entries) tx.add(this.marginManager.managerState(poolKey, managerId));
+		const res = await this.#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 margin manager states: Unknown error`);
+		const results = {};
+		for (let i = 0; i < entries.length; i++) {
+			const commandResult = res.commandResults[i];
+			if (!commandResult || !commandResult.returnValues) throw new Error(`Failed to get margin manager state for index ${i}: No return values`);
+			const [, poolKey] = entries[i];
+			const pool = this.#config.getPool(poolKey);
+			const baseCoin = this.#config.getCoin(pool.baseCoin);
+			const quoteCoin = this.#config.getCoin(pool.quoteCoin);
+			const managerId = normalizeHaneulAddress(bcs.Address.parse(commandResult.returnValues[0].bcs));
+			const deepbookPoolId = normalizeHaneulAddress(bcs.Address.parse(commandResult.returnValues[1].bcs));
+			const riskRatio = Number(bcs.U64.parse(commandResult.returnValues[2].bcs)) / FLOAT_SCALAR;
+			const baseAsset = this.#formatTokenAmount(BigInt(bcs.U64.parse(commandResult.returnValues[3].bcs)), baseCoin.scalar, decimals);
+			const quoteAsset = this.#formatTokenAmount(BigInt(bcs.U64.parse(commandResult.returnValues[4].bcs)), quoteCoin.scalar, decimals);
+			const baseDebt = this.#formatTokenAmount(BigInt(bcs.U64.parse(commandResult.returnValues[5].bcs)), baseCoin.scalar, decimals);
+			const quoteDebt = this.#formatTokenAmount(BigInt(bcs.U64.parse(commandResult.returnValues[6].bcs)), quoteCoin.scalar, decimals);
+			const basePythPrice = bcs.U64.parse(commandResult.returnValues[7].bcs);
+			const basePythDecimals = Number(bcs.u8().parse(new Uint8Array(commandResult.returnValues[8].bcs)));
+			const quotePythPrice = bcs.U64.parse(commandResult.returnValues[9].bcs);
+			const quotePythDecimals = Number(bcs.u8().parse(new Uint8Array(commandResult.returnValues[10].bcs)));
+			const currentPrice = BigInt(bcs.U64.parse(commandResult.returnValues[11].bcs));
+			const lowestTriggerAbovePrice = BigInt(bcs.U64.parse(commandResult.returnValues[12].bcs));
+			const highestTriggerBelowPrice = BigInt(bcs.U64.parse(commandResult.returnValues[13].bcs));
+			results[managerId] = {
+				managerId,
+				deepbookPoolId,
+				riskRatio,
+				baseAsset,
+				quoteAsset,
+				baseDebt,
+				quoteDebt,
+				basePythPrice: basePythPrice.toString(),
+				basePythDecimals,
+				quotePythPrice: quotePythPrice.toString(),
+				quotePythDecimals,
+				currentPrice,
+				lowestTriggerAbovePrice,
+				highestTriggerBelowPrice
+			};
+		}
+		return results;
+	}
+	/**
+	* @description Get the base asset balance of a margin manager
+	* @param {string} marginManagerKey The key to identify the margin manager
+	* @param {number} decimals Number of decimal places to show (default: 6)
+	* @returns {Promise<string>} The base asset balance
+	*/
+	async getMarginManagerBaseBalance(marginManagerKey, decimals = 9) {
+		const manager = this.#config.getMarginManager(marginManagerKey);
+		const tx = new Transaction();
+		tx.add(this.marginManager.baseBalance(manager.poolKey, manager.address));
+		const res = await this.#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 || !res.commandResults[0] || !res.commandResults[0].returnValues) throw new Error(`Failed to get margin manager base balance: Unknown error`);
+		const bytes = res.commandResults[0].returnValues[0].bcs;
+		const pool = this.#config.getPool(manager.poolKey);
+		const baseCoin = this.#config.getCoin(pool.baseCoin);
+		return this.#formatTokenAmount(BigInt(bcs.U64.parse(bytes)), baseCoin.scalar, decimals);
+	}
+	/**
+	* @description Get the quote asset balance of a margin manager
+	* @param {string} marginManagerKey The key to identify the margin manager
+	* @param {number} decimals Number of decimal places to show (default: 6)
+	* @returns {Promise<string>} The quote asset balance
+	*/
+	async getMarginManagerQuoteBalance(marginManagerKey, decimals = 9) {
+		const manager = this.#config.getMarginManager(marginManagerKey);
+		const tx = new Transaction();
+		tx.add(this.marginManager.quoteBalance(manager.poolKey, manager.address));
+		const res = await this.#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 || !res.commandResults[0] || !res.commandResults[0].returnValues) throw new Error(`Failed to get margin manager quote balance: Unknown error`);
+		const bytes = res.commandResults[0].returnValues[0].bcs;
+		const pool = this.#config.getPool(manager.poolKey);
+		const quoteCoin = this.#config.getCoin(pool.quoteCoin);
+		return this.#formatTokenAmount(BigInt(bcs.U64.parse(bytes)), quoteCoin.scalar, decimals);
+	}
+	/**
+	* @description Get the DEEP token balance of a margin manager
+	* @param {string} marginManagerKey The key to identify the margin manager
+	* @param {number} decimals Number of decimal places to show (default: 6)
+	* @returns {Promise<string>} The DEEP token balance
+	*/
+	async getMarginManagerDeepBalance(marginManagerKey, decimals = 6) {
+		const manager = this.#config.getMarginManager(marginManagerKey);
+		const tx = new Transaction();
+		tx.add(this.marginManager.deepBalance(manager.poolKey, manager.address));
+		const res = await this.#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 || !res.commandResults[0] || !res.commandResults[0].returnValues) throw new Error(`Failed to get margin manager DEEP balance: Unknown error`);
+		const bytes = res.commandResults[0].returnValues[0].bcs;
+		const deepCoin = this.#config.getCoin("DEEP");
+		return this.#formatTokenAmount(BigInt(bcs.U64.parse(bytes)), deepCoin.scalar, decimals);
+	}
+	/**
+	* @description Get base, quote, and DEEP balances for multiple margin managers in a single dry run call
+	* @param {Record<string, string>} marginManagers Map of marginManagerId -> poolKey
+	* @param {number} decimals Number of decimal places for formatting (default: 9)
+	* @returns {Promise<Record<string, { base: string, quote: string, deep: string }>>} Object keyed by managerId
+	*/
+	async getMarginManagerBalances(marginManagers, decimals = 9) {
+		const entries = Object.entries(marginManagers);
+		if (entries.length === 0) return {};
+		const tx = new Transaction();
+		for (const [managerId, poolKey] of entries) {
+			tx.add(this.marginManager.baseBalance(poolKey, managerId));
+			tx.add(this.marginManager.quoteBalance(poolKey, managerId));
+			tx.add(this.marginManager.deepBalance(poolKey, managerId));
+		}
+		const res = await this.#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 margin manager balances: No command results");
+		const results = {};
+		const deepCoin = this.#config.getCoin("DEEP");
+		for (let i = 0; i < entries.length; i++) {
+			const [managerId, poolKey] = entries[i];
+			const pool = this.#config.getPool(poolKey);
+			const baseCoin = this.#config.getCoin(pool.baseCoin);
+			const quoteCoin = this.#config.getCoin(pool.quoteCoin);
+			const baseResult = res.commandResults[i * 3];
+			const quoteResult = res.commandResults[i * 3 + 1];
+			const deepResult = res.commandResults[i * 3 + 2];
+			if (!baseResult?.returnValues || !quoteResult?.returnValues || !deepResult?.returnValues) throw new Error(`Failed to get balances for margin manager ${managerId}: No return values`);
+			results[managerId] = {
+				base: this.#formatTokenAmount(BigInt(bcs.U64.parse(baseResult.returnValues[0].bcs)), baseCoin.scalar, decimals),
+				quote: this.#formatTokenAmount(BigInt(bcs.U64.parse(quoteResult.returnValues[0].bcs)), quoteCoin.scalar, decimals),
+				deep: this.#formatTokenAmount(BigInt(bcs.U64.parse(deepResult.returnValues[0].bcs)), deepCoin.scalar, decimals)
+			};
+		}
+		return results;
+	}
+	/**
+	* @description Get account order details for a margin manager.
+	* This retrieves the balance manager from the margin manager and returns order details.
+	* @param {string} marginManagerKey The key to identify the margin manager
+	* @returns {Promise<Array>} Array of order details
+	*/
+	async getMarginAccountOrderDetails(marginManagerKey) {
+		const manager = this.#config.getMarginManager(marginManagerKey);
+		const tx = new Transaction();
+		tx.add(this.marginManager.getMarginAccountOrderDetails(manager.poolKey, manager.address));
+		tx.setSenderIfNotSet(normalizeHaneulAddress(this.#address));
+		const res = await this.#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 || !res.commandResults[0] || !res.commandResults[0].returnValues) throw new Error(`Failed to get conditional order IDs: Unknown error`);
+		try {
+			const bytes = res.commandResults[1].returnValues[0].bcs;
+			return bcs.vector(Order).parse(bytes);
+		} catch {
+			return [];
+		}
+	}
+	/**
+	* @description Get all conditional order IDs for a margin manager
+	* @param {string} marginManagerKey The key to identify the margin manager
+	* @returns {Promise<string[]>} Array of conditional order IDs
+	*/
+	async getConditionalOrderIds(marginManagerKey) {
+		const manager = this.#config.getMarginManager(marginManagerKey);
+		const tx = new Transaction();
+		tx.add(this.marginTPSL.conditionalOrderIds(manager.poolKey, manager.address));
+		const res = await this.#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 || !res.commandResults[0] || !res.commandResults[0].returnValues) throw new Error(`Failed to get conditional order IDs: Unknown error`);
+		const bytes = res.commandResults[0].returnValues[0].bcs;
+		return bcs.vector(bcs.u64()).parse(bytes).map((id) => id.toString());
+	}
+	/**
+	* @description Get the lowest trigger price for trigger_above orders
+	* Returns MAX_U64 if there are no trigger_above orders
+	* @param {string} marginManagerKey The key to identify the margin manager
+	* @returns {Promise<bigint>} The lowest trigger above price
+	*/
+	async getLowestTriggerAbovePrice(marginManagerKey) {
+		const manager = this.#config.getMarginManager(marginManagerKey);
+		const tx = new Transaction();
+		tx.add(this.marginTPSL.lowestTriggerAbovePrice(manager.poolKey, manager.address));
+		const res = await this.#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 || !res.commandResults[0] || !res.commandResults[0].returnValues) throw new Error(`Failed to get lowest trigger above price: Unknown error`);
+		const bytes = res.commandResults[0].returnValues[0].bcs;
+		return BigInt(bcs.U64.parse(bytes));
+	}
+	/**
+	* @description Get the highest trigger price for trigger_below orders
+	* Returns 0 if there are no trigger_below orders
+	* @param {string} marginManagerKey The key to identify the margin manager
+	* @returns {Promise<bigint>} The highest trigger below price
+	*/
+	async getHighestTriggerBelowPrice(marginManagerKey) {
+		const manager = this.#config.getMarginManager(marginManagerKey);
+		const tx = new Transaction();
+		tx.add(this.marginTPSL.highestTriggerBelowPrice(manager.poolKey, manager.address));
+		const res = await this.#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 || !res.commandResults[0] || !res.commandResults[0].returnValues) throw new Error(`Failed to get highest trigger below price: Unknown error`);
+		const bytes = res.commandResults[0].returnValues[0].bcs;
+		return BigInt(bcs.U64.parse(bytes));
+	}
+	/**
+	* @description Check if a deepbook pool is enabled for margin trading
+	* @param {string} poolKey The key to identify the pool
+	* @returns {Promise<boolean>} True if the pool is enabled for margin trading
+	*/
+	async isPoolEnabledForMargin(poolKey) {
+		const tx = new Transaction();
+		tx.add(this.marginRegistry.poolEnabled(poolKey));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return bcs.Bool.parse(bytes);
+	}
+	/**
+	* @description Get the margin manager IDs for a given owner address
+	* @param {string} owner The owner address
+	* @returns {Promise<string[]>} Array of margin manager IDs
+	*/
+	async getMarginManagerIdsForOwner(owner) {
+		const tx = new Transaction();
+		tx.add(this.marginRegistry.getMarginManagerIds(owner));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return VecSet(bcs.Address).parse(bytes).contents.map((id) => normalizeHaneulAddress(id));
+	}
+	/**
+	* @description Get the base margin pool ID for a deepbook pool
+	* @param {string} poolKey The key to identify the pool
+	* @returns {Promise<string>} The base margin pool ID
+	*/
+	async getBaseMarginPoolId(poolKey) {
+		const tx = new Transaction();
+		tx.add(this.marginRegistry.baseMarginPoolId(poolKey));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return "0x" + bcs.Address.parse(bytes);
+	}
+	/**
+	* @description Get the quote margin pool ID for a deepbook pool
+	* @param {string} poolKey The key to identify the pool
+	* @returns {Promise<string>} The quote margin pool ID
+	*/
+	async getQuoteMarginPoolId(poolKey) {
+		const tx = new Transaction();
+		tx.add(this.marginRegistry.quoteMarginPoolId(poolKey));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return "0x" + bcs.Address.parse(bytes);
+	}
+	/**
+	* @description Get the minimum withdraw risk ratio for a deepbook pool
+	* @param {string} poolKey The key to identify the pool
+	* @returns {Promise<number>} The minimum withdraw risk ratio as a decimal (e.g., 1.5 for 150%)
+	*/
+	async getMinWithdrawRiskRatio(poolKey) {
+		const tx = new Transaction();
+		tx.add(this.marginRegistry.minWithdrawRiskRatio(poolKey));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return Number(bcs.U64.parse(bytes)) / FLOAT_SCALAR;
+	}
+	/**
+	* @description Get the minimum borrow risk ratio for a deepbook pool
+	* @param {string} poolKey The key to identify the pool
+	* @returns {Promise<number>} The minimum borrow risk ratio as a decimal (e.g., 1.25 for 125%)
+	*/
+	async getMinBorrowRiskRatio(poolKey) {
+		const tx = new Transaction();
+		tx.add(this.marginRegistry.minBorrowRiskRatio(poolKey));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return Number(bcs.U64.parse(bytes)) / FLOAT_SCALAR;
+	}
+	/**
+	* @description Get the liquidation risk ratio for a deepbook pool
+	* @param {string} poolKey The key to identify the pool
+	* @returns {Promise<number>} The liquidation risk ratio as a decimal (e.g., 1.125 for 112.5%)
+	*/
+	async getLiquidationRiskRatio(poolKey) {
+		const tx = new Transaction();
+		tx.add(this.marginRegistry.liquidationRiskRatio(poolKey));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return Number(bcs.U64.parse(bytes)) / FLOAT_SCALAR;
+	}
+	/**
+	* @description Get the target liquidation risk ratio for a deepbook pool
+	* @param {string} poolKey The key to identify the pool
+	* @returns {Promise<number>} The target liquidation risk ratio as a decimal (e.g., 1.25 for 125%)
+	*/
+	async getTargetLiquidationRiskRatio(poolKey) {
+		const tx = new Transaction();
+		tx.add(this.marginRegistry.targetLiquidationRiskRatio(poolKey));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return Number(bcs.U64.parse(bytes)) / FLOAT_SCALAR;
+	}
+	/**
+	* @description Get the user liquidation reward for a deepbook pool
+	* @param {string} poolKey The key to identify the pool
+	* @returns {Promise<number>} The user liquidation reward as a decimal (e.g., 0.05 for 5%)
+	*/
+	async getUserLiquidationReward(poolKey) {
+		const tx = new Transaction();
+		tx.add(this.marginRegistry.userLiquidationReward(poolKey));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return Number(bcs.U64.parse(bytes)) / FLOAT_SCALAR;
+	}
+	/**
+	* @description Get the pool liquidation reward for a deepbook pool
+	* @param {string} poolKey The key to identify the pool
+	* @returns {Promise<number>} The pool liquidation reward as a decimal (e.g., 0.05 for 5%)
+	*/
+	async getPoolLiquidationReward(poolKey) {
+		const tx = new Transaction();
+		tx.add(this.marginRegistry.poolLiquidationReward(poolKey));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return Number(bcs.U64.parse(bytes)) / FLOAT_SCALAR;
+	}
+	/**
+	* @description Get all allowed maintainer cap IDs
+	* @returns {Promise<string[]>} Array of allowed maintainer cap IDs
+	*/
+	async getAllowedMaintainers() {
+		const tx = new Transaction();
+		tx.add(this.marginRegistry.allowedMaintainers());
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return VecSet(bcs.Address).parse(bytes).contents.map((id) => normalizeHaneulAddress(id));
+	}
+	/**
+	* @description Get all allowed pause cap IDs
+	* @returns {Promise<string[]>} Array of allowed pause cap IDs
+	*/
+	async getAllowedPauseCaps() {
+		const tx = new Transaction();
+		tx.add(this.marginRegistry.allowedPauseCaps());
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return VecSet(bcs.Address).parse(bytes).contents.map((id) => normalizeHaneulAddress(id));
+	}
+	/**
+	* @description Check if a pool is a stable pool
+	* @param {string} poolKey Key of the pool
+	* @returns {Promise<boolean>} Whether the pool is a stable pool
+	*/
+	async stablePool(poolKey) {
+		const tx = new Transaction();
+		tx.add(this.deepBook.stablePool(poolKey));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return bcs.bool().parse(bytes);
+	}
+	/**
+	* @description Check if a pool is registered
+	* @param {string} poolKey Key of the pool
+	* @returns {Promise<boolean>} Whether the pool is registered
+	*/
+	async registeredPool(poolKey) {
+		const tx = new Transaction();
+		tx.add(this.deepBook.registeredPool(poolKey));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return bcs.bool().parse(bytes);
+	}
+	/**
+	* @description Get the quote quantity out using input token as fee
+	* @param {string} poolKey Key of the pool
+	* @param {number} baseQuantity Base quantity
+	* @returns {Promise<{baseQuantity: number, baseOut: number, quoteOut: number, deepRequired: number}>}
+	*/
+	async getQuoteQuantityOutInputFee(poolKey, baseQuantity) {
+		const tx = new Transaction();
+		const pool = this.#config.getPool(poolKey);
+		const baseScalar = this.#config.getCoin(pool.baseCoin).scalar;
+		const quoteScalar = this.#config.getCoin(pool.quoteCoin).scalar;
+		tx.add(this.deepBook.getQuoteQuantityOutInputFee(poolKey, baseQuantity));
+		const res = await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		});
+		const baseOut = Number(bcs.U64.parse(res.commandResults[0].returnValues[0].bcs));
+		const quoteOut = Number(bcs.U64.parse(res.commandResults[0].returnValues[1].bcs));
+		const deepRequired = Number(bcs.U64.parse(res.commandResults[0].returnValues[2].bcs));
+		return {
+			baseQuantity,
+			baseOut: Number((baseOut / baseScalar).toFixed(9)),
+			quoteOut: Number((quoteOut / quoteScalar).toFixed(9)),
+			deepRequired: Number((deepRequired / DEEP_SCALAR).toFixed(9))
+		};
+	}
+	/**
+	* @description Get the base quantity out using input token as fee
+	* @param {string} poolKey Key of the pool
+	* @param {number} quoteQuantity Quote quantity
+	* @returns {Promise<{quoteQuantity: number, baseOut: number, quoteOut: number, deepRequired: number}>}
+	*/
+	async getBaseQuantityOutInputFee(poolKey, quoteQuantity) {
+		const tx = new Transaction();
+		const pool = this.#config.getPool(poolKey);
+		const baseScalar = this.#config.getCoin(pool.baseCoin).scalar;
+		const quoteScalar = this.#config.getCoin(pool.quoteCoin).scalar;
+		tx.add(this.deepBook.getBaseQuantityOutInputFee(poolKey, quoteQuantity));
+		const res = await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		});
+		const baseOut = Number(bcs.U64.parse(res.commandResults[0].returnValues[0].bcs));
+		const quoteOut = Number(bcs.U64.parse(res.commandResults[0].returnValues[1].bcs));
+		const deepRequired = Number(bcs.U64.parse(res.commandResults[0].returnValues[2].bcs));
+		return {
+			quoteQuantity,
+			baseOut: Number((baseOut / baseScalar).toFixed(9)),
+			quoteOut: Number((quoteOut / quoteScalar).toFixed(9)),
+			deepRequired: Number((deepRequired / DEEP_SCALAR).toFixed(9))
+		};
+	}
+	/**
+	* @description Get the quantity out using input token as fee
+	* @param {string} poolKey Key of the pool
+	* @param {number} baseQuantity Base quantity
+	* @param {number} quoteQuantity Quote quantity
+	* @returns {Promise<{baseQuantity: number, quoteQuantity: number, baseOut: number, quoteOut: number, deepRequired: number}>}
+	*/
+	async getQuantityOutInputFee(poolKey, baseQuantity, quoteQuantity) {
+		const tx = new Transaction();
+		const pool = this.#config.getPool(poolKey);
+		const baseScalar = this.#config.getCoin(pool.baseCoin).scalar;
+		const quoteScalar = this.#config.getCoin(pool.quoteCoin).scalar;
+		tx.add(this.deepBook.getQuantityOutInputFee(poolKey, baseQuantity, quoteQuantity));
+		const res = await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		});
+		const baseOut = Number(bcs.U64.parse(res.commandResults[0].returnValues[0].bcs));
+		const quoteOut = Number(bcs.U64.parse(res.commandResults[0].returnValues[1].bcs));
+		const deepRequired = Number(bcs.U64.parse(res.commandResults[0].returnValues[2].bcs));
+		return {
+			baseQuantity,
+			quoteQuantity,
+			baseOut: Number((baseOut / baseScalar).toFixed(9)),
+			quoteOut: Number((quoteOut / quoteScalar).toFixed(9)),
+			deepRequired: Number((deepRequired / DEEP_SCALAR).toFixed(9))
+		};
+	}
+	/**
+	* @description Get the base quantity needed to receive target quote quantity
+	* @param {string} poolKey Key of the pool
+	* @param {number} targetQuoteQuantity Target quote quantity
+	* @param {boolean} payWithDeep Whether to pay fees with DEEP
+	* @returns {Promise<{baseIn: number, quoteOut: number, deepRequired: number}>}
+	*/
+	async getBaseQuantityIn(poolKey, targetQuoteQuantity, payWithDeep) {
+		const tx = new Transaction();
+		const pool = this.#config.getPool(poolKey);
+		const baseScalar = this.#config.getCoin(pool.baseCoin).scalar;
+		const quoteScalar = this.#config.getCoin(pool.quoteCoin).scalar;
+		tx.add(this.deepBook.getBaseQuantityIn(poolKey, targetQuoteQuantity, payWithDeep));
+		const res = await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		});
+		const baseIn = Number(bcs.U64.parse(res.commandResults[0].returnValues[0].bcs));
+		const quoteOut = Number(bcs.U64.parse(res.commandResults[0].returnValues[1].bcs));
+		const deepRequired = Number(bcs.U64.parse(res.commandResults[0].returnValues[2].bcs));
+		return {
+			baseIn: Number((baseIn / baseScalar).toFixed(9)),
+			quoteOut: Number((quoteOut / quoteScalar).toFixed(9)),
+			deepRequired: Number((deepRequired / DEEP_SCALAR).toFixed(9))
+		};
+	}
+	/**
+	* @description Get the quote quantity needed to receive target base quantity
+	* @param {string} poolKey Key of the pool
+	* @param {number} targetBaseQuantity Target base quantity
+	* @param {boolean} payWithDeep Whether to pay fees with DEEP
+	* @returns {Promise<{baseOut: number, quoteIn: number, deepRequired: number}>}
+	*/
+	async getQuoteQuantityIn(poolKey, targetBaseQuantity, payWithDeep) {
+		const tx = new Transaction();
+		const pool = this.#config.getPool(poolKey);
+		const baseScalar = this.#config.getCoin(pool.baseCoin).scalar;
+		const quoteScalar = this.#config.getCoin(pool.quoteCoin).scalar;
+		tx.add(this.deepBook.getQuoteQuantityIn(poolKey, targetBaseQuantity, payWithDeep));
+		const res = await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		});
+		const baseOut = Number(bcs.U64.parse(res.commandResults[0].returnValues[0].bcs));
+		const quoteIn = Number(bcs.U64.parse(res.commandResults[0].returnValues[1].bcs));
+		const deepRequired = Number(bcs.U64.parse(res.commandResults[0].returnValues[2].bcs));
+		return {
+			baseOut: Number((baseOut / baseScalar).toFixed(9)),
+			quoteIn: Number((quoteIn / quoteScalar).toFixed(9)),
+			deepRequired: Number((deepRequired / DEEP_SCALAR).toFixed(9))
+		};
+	}
+	/**
+	* @description Get account order details for a balance manager
+	* @param {string} poolKey Key of the pool
+	* @param {string} managerKey Key of the balance manager
+	* @returns {Promise<Array>} Array of order details
+	*/
+	async getAccountOrderDetails(poolKey, managerKey) {
+		const tx = new Transaction();
+		tx.add(this.deepBook.getAccountOrderDetails(poolKey, managerKey));
+		const res = await this.#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 [];
+		}
+	}
+	/**
+	* @description Get the DEEP required for an order
+	* @param {string} poolKey Key of the pool
+	* @param {number} baseQuantity Base quantity
+	* @param {number} price Price
+	* @returns {Promise<{deepRequiredTaker: number, deepRequiredMaker: number}>}
+	*/
+	async getOrderDeepRequired(poolKey, baseQuantity, price) {
+		const tx = new Transaction();
+		tx.add(this.deepBook.getOrderDeepRequired(poolKey, baseQuantity, price));
+		const res = await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		});
+		const deepRequiredTaker = Number(bcs.U64.parse(res.commandResults[0].returnValues[0].bcs));
+		const deepRequiredMaker = Number(bcs.U64.parse(res.commandResults[0].returnValues[1].bcs));
+		return {
+			deepRequiredTaker: Number((deepRequiredTaker / DEEP_SCALAR).toFixed(9)),
+			deepRequiredMaker: Number((deepRequiredMaker / DEEP_SCALAR).toFixed(9))
+		};
+	}
+	/**
+	* @description Check if account exists for a balance manager
+	* @param {string} poolKey Key of the pool
+	* @param {string} managerKey Key of the balance manager
+	* @returns {Promise<boolean>} Whether account exists
+	*/
+	async accountExists(poolKey, managerKey) {
+		const tx = new Transaction();
+		tx.add(this.deepBook.accountExists(poolKey, managerKey));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return bcs.bool().parse(bytes);
+	}
+	/**
+	* @description Get the next epoch trade parameters
+	* @param {string} poolKey Key of the pool
+	* @returns {Promise<{takerFee: number, makerFee: number, stakeRequired: number}>}
+	*/
+	async poolTradeParamsNext(poolKey) {
+		const tx = new Transaction();
+		tx.add(this.deepBook.poolTradeParamsNext(poolKey));
+		const res = await this.#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
+		};
+	}
+	/**
+	* @description Get the quorum for a pool
+	* @param {string} poolKey Key of the pool
+	* @returns {Promise<number>} The quorum amount in DEEP
+	*/
+	async quorum(poolKey) {
+		const tx = new Transaction();
+		tx.add(this.deepBook.quorum(poolKey));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return Number(bcs.U64.parse(bytes)) / DEEP_SCALAR;
+	}
+	/**
+	* @description Get the pool ID
+	* @param {string} poolKey Key of the pool
+	* @returns {Promise<string>} The pool ID
+	*/
+	async poolId(poolKey) {
+		const tx = new Transaction();
+		tx.add(this.deepBook.poolId(poolKey));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return normalizeHaneulAddress(bcs.Address.parse(bytes));
+	}
+	/**
+	* @description Check if a limit order can be placed
+	* @param {CanPlaceLimitOrderParams} params Parameters for checking limit order placement
+	* @returns {Promise<boolean>} Whether order can be placed
+	*/
+	async canPlaceLimitOrder(params) {
+		const tx = new Transaction();
+		tx.add(this.deepBook.canPlaceLimitOrder(params));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return bcs.bool().parse(bytes);
+	}
+	/**
+	* @description Check if a market order can be placed
+	* @param {CanPlaceMarketOrderParams} params Parameters for checking market order placement
+	* @returns {Promise<boolean>} Whether order can be placed
+	*/
+	async canPlaceMarketOrder(params) {
+		const tx = new Transaction();
+		tx.add(this.deepBook.canPlaceMarketOrder(params));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return bcs.bool().parse(bytes);
+	}
+	/**
+	* @description Check if market order params are valid
+	* @param {string} poolKey Key of the pool
+	* @param {number} quantity Quantity
+	* @returns {Promise<boolean>} Whether params are valid
+	*/
+	async checkMarketOrderParams(poolKey, quantity) {
+		const tx = new Transaction();
+		tx.add(this.deepBook.checkMarketOrderParams(poolKey, quantity));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return bcs.bool().parse(bytes);
+	}
+	/**
+	* @description Check if limit order params are valid
+	* @param {string} poolKey Key of the pool
+	* @param {number} price Price
+	* @param {number} quantity Quantity
+	* @param {number} expireTimestamp Expiration timestamp
+	* @returns {Promise<boolean>} Whether params are valid
+	*/
+	async checkLimitOrderParams(poolKey, price, quantity, expireTimestamp) {
+		const tx = new Transaction();
+		tx.add(this.deepBook.checkLimitOrderParams(poolKey, price, quantity, expireTimestamp));
+		const bytes = (await this.#client.core.simulateTransaction({
+			transaction: tx,
+			include: {
+				commandResults: true,
+				effects: true
+			}
+		})).commandResults[0].returnValues[0].bcs;
+		return bcs.bool().parse(bytes);
+	}
+	/**
+	* @description Helper function to format token amounts without floating point errors
+	* @param {bigint} rawAmount The raw amount as bigint
+	* @param {number} scalar The token scalar (e.g., 1000000000 for 9 decimals)
+	* @param {number} decimals Number of decimal places to show
+	* @returns {string} Formatted amount as string
+	*/
+	#formatTokenAmount(rawAmount, scalar, decimals) {
+		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 trimmed = fractionalPart.toString().padStart(scalarDigits, "0").slice(0, decimals).replace(/0+$/, "");
+		if (!trimmed) return integerPart.toString();
+		return `${integerPart}.${trimmed}`;
+	}
+};
+
+//#endregion
+export { DeepBookClient, deepbook };
+//# sourceMappingURL=client.mjs.map