@mysten/deepbook-v3 1.1.4 → 1.2.0

package/src/queries/priceFeedQueries.ts

@@ -0,0 +1,141 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Transaction } from '@mysten/sui/transactions';
+
+import { PriceInfoObject } from '../contracts/pyth/price_info.js';
+import { SuiPriceServiceConnection, SuiPythClient } from '../pyth/pyth.js';
+import { PRICE_INFO_OBJECT_MAX_AGE_MS } from '../utils/config.js';
+import type { QueryContext } from './context.js';
+
+export class PriceFeedQueries {
+	#ctx: QueryContext;
+
+	constructor(ctx: QueryContext) {
+		this.#ctx = ctx;
+	}
+
+	async getPriceInfoObject(tx: Transaction, coinKey: string): Promise<string> {
+		this.#ctx.config.requirePyth();
+		const currentTime = Date.now();
+		const priceInfoObjectAge = await this.getPriceInfoObjectAge(coinKey);
+		if (
+			priceInfoObjectAge &&
+			currentTime - priceInfoObjectAge * 1000 < PRICE_INFO_OBJECT_MAX_AGE_MS
+		) {
+			return await this.#ctx.config.getCoin(coinKey).priceInfoObjectId!;
+		}
+
+		const endpoint =
+			this.#ctx.config.network === 'testnet'
+				? 'https://hermes-beta.pyth.network'
+				: 'https://hermes.pyth.network';
+		const connection = new SuiPriceServiceConnection(endpoint);
+
+		const priceIDs = [this.#ctx.config.getCoin(coinKey).feed!];
+
+		const priceUpdateData = await connection.getPriceFeedsUpdateData(priceIDs);
+
+		const wormholeStateId = this.#ctx.config.pyth.wormholeStateId;
+		const pythStateId = this.#ctx.config.pyth.pythStateId;
+
+		const client = new SuiPythClient(this.#ctx.client, pythStateId, wormholeStateId);
+
+		return (await client.updatePriceFeeds(tx, priceUpdateData, priceIDs))[0];
+	}
+
+	async getPriceInfoObjects(tx: Transaction, coinKeys: string[]): Promise<Record<string, string>> {
+		this.#ctx.config.requirePyth();
+		if (coinKeys.length === 0) {
+			return {};
+		}
+
+		const currentTime = Date.now();
+
+		const coinToObjectId: Record<string, string> = {};
+		const objectIds: string[] = [];
+		for (const coinKey of coinKeys) {
+			const priceInfoObjectId = this.#ctx.config.getCoin(coinKey).priceInfoObjectId!;
+			coinToObjectId[coinKey] = priceInfoObjectId;
+			objectIds.push(priceInfoObjectId);
+		}
+
+		const res = await this.#ctx.client.core.getObjects({
+			objectIds,
+			include: { content: true },
+		});
+
+		const staleCoinKeys: string[] = [];
+		const result: Record<string, string> = {};
+
+		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);
+			const arrivalTime = Number(priceInfoObject.price_info.arrival_time);
+			const age = currentTime - arrivalTime * 1000;
+
+			if (age >= PRICE_INFO_OBJECT_MAX_AGE_MS) {
+				staleCoinKeys.push(coinKey);
+			} else {
+				result[coinKey] = coinToObjectId[coinKey];
+			}
+		}
+
+		if (staleCoinKeys.length === 0) {
+			return result;
+		}
+
+		const staleFeedIds: string[] = [];
+		const feedIdToCoinKey: Record<string, string> = {};
+		for (const coinKey of staleCoinKeys) {
+			const feedId = this.#ctx.config.getCoin(coinKey).feed!;
+			staleFeedIds.push(feedId);
+			feedIdToCoinKey[feedId] = coinKey;
+		}
+
+		const endpoint =
+			this.#ctx.config.network === 'testnet'
+				? 'https://hermes-beta.pyth.network'
+				: 'https://hermes.pyth.network';
+		const connection = new SuiPriceServiceConnection(endpoint);
+
+		const priceUpdateData = await connection.getPriceFeedsUpdateData(staleFeedIds);
+
+		const wormholeStateId = this.#ctx.config.pyth.wormholeStateId;
+		const pythStateId = this.#ctx.config.pyth.pythStateId;
+		const pythClient = new SuiPythClient(this.#ctx.client, pythStateId, wormholeStateId);
+
+		const updatedObjectIds = await pythClient.updatePriceFeeds(tx, priceUpdateData, staleFeedIds);
+
+		for (let i = 0; i < staleFeedIds.length; i++) {
+			const coinKey = feedIdToCoinKey[staleFeedIds[i]];
+			result[coinKey] = updatedObjectIds[i];
+		}
+
+		return result;
+	}
+
+	async getPriceInfoObjectAge(coinKey: string): Promise<number> {
+		const priceInfoObjectId = this.#ctx.config.getCoin(coinKey).priceInfoObjectId!;
+		const res = await this.#ctx.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);
+	}
+}

package/src/queries/quantityQueries.ts

@@ -0,0 +1,266 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { bcs } from '@mysten/sui/bcs';
+import { Transaction } from '@mysten/sui/transactions';
+
+import type {
+	BaseQuantityIn,
+	BaseQuantityOut,
+	OrderDeepRequiredResult,
+	QuantityOut,
+	QuoteQuantityIn,
+	QuoteQuantityOut,
+} from '../types/index.js';
+import { DEEP_SCALAR } from '../utils/config.js';
+import type { QueryContext } from './context.js';
+
+export class QuantityQueries {
+	#ctx: QueryContext;
+
+	constructor(ctx: QueryContext) {
+		this.#ctx = ctx;
+	}
+
+	async getQuoteQuantityOut(
+		poolKey: string,
+		baseQuantity: number | bigint,
+	): Promise<QuoteQuantityOut> {
+		const tx = new Transaction();
+		const pool = this.#ctx.config.getPool(poolKey);
+		const baseScalar = this.#ctx.config.getCoin(pool.baseCoin).scalar;
+		const quoteScalar = this.#ctx.config.getCoin(pool.quoteCoin).scalar;
+
+		tx.add(this.#ctx.deepBook.getQuoteQuantityOut(poolKey, baseQuantity));
+		const res = await this.#ctx.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: Number(baseQuantity),
+			baseOut: Number((baseOut / baseScalar).toFixed(9)),
+			quoteOut: Number((quoteOut / quoteScalar).toFixed(9)),
+			deepRequired: Number((deepRequired / DEEP_SCALAR).toFixed(9)),
+		};
+	}
+
+	async getBaseQuantityOut(
+		poolKey: string,
+		quoteQuantity: number | bigint,
+	): Promise<BaseQuantityOut> {
+		const tx = new Transaction();
+		const pool = this.#ctx.config.getPool(poolKey);
+		const baseScalar = this.#ctx.config.getCoin(pool.baseCoin).scalar;
+		const quoteScalar = this.#ctx.config.getCoin(pool.quoteCoin).scalar;
+
+		tx.add(this.#ctx.deepBook.getBaseQuantityOut(poolKey, quoteQuantity));
+		const res = await this.#ctx.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: Number(quoteQuantity),
+			baseOut: Number((baseOut / baseScalar).toFixed(9)),
+			quoteOut: Number((quoteOut / quoteScalar).toFixed(9)),
+			deepRequired: Number((deepRequired / DEEP_SCALAR).toFixed(9)),
+		};
+	}
+
+	async getQuantityOut(
+		poolKey: string,
+		baseQuantity: number | bigint,
+		quoteQuantity: number | bigint,
+	): Promise<QuantityOut> {
+		const tx = new Transaction();
+		const pool = this.#ctx.config.getPool(poolKey);
+		const baseScalar = this.#ctx.config.getCoin(pool.baseCoin).scalar;
+		const quoteScalar = this.#ctx.config.getCoin(pool.quoteCoin).scalar;
+
+		tx.add(this.#ctx.deepBook.getQuantityOut(poolKey, baseQuantity, quoteQuantity));
+		const res = await this.#ctx.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: Number(baseQuantity),
+			quoteQuantity: Number(quoteQuantity),
+			baseOut: Number((baseOut / baseScalar).toFixed(9)),
+			quoteOut: Number((quoteOut / quoteScalar).toFixed(9)),
+			deepRequired: Number((deepRequired / DEEP_SCALAR).toFixed(9)),
+		};
+	}
+
+	async getQuoteQuantityOutInputFee(
+		poolKey: string,
+		baseQuantity: number | bigint,
+	): Promise<QuoteQuantityOut> {
+		const tx = new Transaction();
+		const pool = this.#ctx.config.getPool(poolKey);
+		const baseScalar = this.#ctx.config.getCoin(pool.baseCoin).scalar;
+		const quoteScalar = this.#ctx.config.getCoin(pool.quoteCoin).scalar;
+
+		tx.add(this.#ctx.deepBook.getQuoteQuantityOutInputFee(poolKey, baseQuantity));
+		const res = await this.#ctx.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: Number(baseQuantity),
+			baseOut: Number((baseOut / baseScalar).toFixed(9)),
+			quoteOut: Number((quoteOut / quoteScalar).toFixed(9)),
+			deepRequired: Number((deepRequired / DEEP_SCALAR).toFixed(9)),
+		};
+	}
+
+	async getBaseQuantityOutInputFee(
+		poolKey: string,
+		quoteQuantity: number | bigint,
+	): Promise<BaseQuantityOut> {
+		const tx = new Transaction();
+		const pool = this.#ctx.config.getPool(poolKey);
+		const baseScalar = this.#ctx.config.getCoin(pool.baseCoin).scalar;
+		const quoteScalar = this.#ctx.config.getCoin(pool.quoteCoin).scalar;
+
+		tx.add(this.#ctx.deepBook.getBaseQuantityOutInputFee(poolKey, quoteQuantity));
+		const res = await this.#ctx.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: Number(quoteQuantity),
+			baseOut: Number((baseOut / baseScalar).toFixed(9)),
+			quoteOut: Number((quoteOut / quoteScalar).toFixed(9)),
+			deepRequired: Number((deepRequired / DEEP_SCALAR).toFixed(9)),
+		};
+	}
+
+	async getQuantityOutInputFee(
+		poolKey: string,
+		baseQuantity: number | bigint,
+		quoteQuantity: number | bigint,
+	): Promise<QuantityOut> {
+		const tx = new Transaction();
+		const pool = this.#ctx.config.getPool(poolKey);
+		const baseScalar = this.#ctx.config.getCoin(pool.baseCoin).scalar;
+		const quoteScalar = this.#ctx.config.getCoin(pool.quoteCoin).scalar;
+
+		tx.add(this.#ctx.deepBook.getQuantityOutInputFee(poolKey, baseQuantity, quoteQuantity));
+		const res = await this.#ctx.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: Number(baseQuantity),
+			quoteQuantity: Number(quoteQuantity),
+			baseOut: Number((baseOut / baseScalar).toFixed(9)),
+			quoteOut: Number((quoteOut / quoteScalar).toFixed(9)),
+			deepRequired: Number((deepRequired / DEEP_SCALAR).toFixed(9)),
+		};
+	}
+
+	async getBaseQuantityIn(
+		poolKey: string,
+		targetQuoteQuantity: number | bigint,
+		payWithDeep: boolean,
+	): Promise<BaseQuantityIn> {
+		const tx = new Transaction();
+		const pool = this.#ctx.config.getPool(poolKey);
+		const baseScalar = this.#ctx.config.getCoin(pool.baseCoin).scalar;
+		const quoteScalar = this.#ctx.config.getCoin(pool.quoteCoin).scalar;
+
+		tx.add(this.#ctx.deepBook.getBaseQuantityIn(poolKey, targetQuoteQuantity, payWithDeep));
+		const res = await this.#ctx.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)),
+		};
+	}
+
+	async getQuoteQuantityIn(
+		poolKey: string,
+		targetBaseQuantity: number | bigint,
+		payWithDeep: boolean,
+	): Promise<QuoteQuantityIn> {
+		const tx = new Transaction();
+		const pool = this.#ctx.config.getPool(poolKey);
+		const baseScalar = this.#ctx.config.getCoin(pool.baseCoin).scalar;
+		const quoteScalar = this.#ctx.config.getCoin(pool.quoteCoin).scalar;
+
+		tx.add(this.#ctx.deepBook.getQuoteQuantityIn(poolKey, targetBaseQuantity, payWithDeep));
+		const res = await this.#ctx.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)),
+		};
+	}
+
+	async getOrderDeepRequired(
+		poolKey: string,
+		baseQuantity: number | bigint,
+		price: number | bigint,
+	): Promise<OrderDeepRequiredResult> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.deepBook.getOrderDeepRequired(poolKey, baseQuantity, price));
+
+		const res = await this.#ctx.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)),
+		};
+	}
+}

package/src/queries/referralQueries.ts

@@ -0,0 +1,112 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { bcs } from '@mysten/sui/bcs';
+import { Transaction } from '@mysten/sui/transactions';
+import { normalizeSuiAddress } from '@mysten/sui/utils';
+
+import type { ReferralBalances } from '../types/index.js';
+import { DEEP_SCALAR, FLOAT_SCALAR } from '../utils/config.js';
+import type { QueryContext } from './context.js';
+
+export class ReferralQueries {
+	#ctx: QueryContext;
+
+	constructor(ctx: QueryContext) {
+		this.#ctx = ctx;
+	}
+
+	async balanceManagerReferralOwner(referral: string): Promise<string> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.balanceManager.balanceManagerReferralOwner(referral));
+
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const bytes = res.commandResults![0].returnValues[0].bcs;
+		return bcs.Address.parse(bytes);
+	}
+
+	async getPoolReferralBalances(poolKey: string, referral: string): Promise<ReferralBalances> {
+		const tx = new Transaction();
+		const pool = this.#ctx.config.getPool(poolKey);
+		const baseScalar = this.#ctx.config.getCoin(pool.baseCoin).scalar;
+		const quoteScalar = this.#ctx.config.getCoin(pool.quoteCoin).scalar;
+
+		tx.add(this.#ctx.deepBook.getPoolReferralBalances(poolKey, referral));
+
+		const res = await this.#ctx.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,
+		};
+	}
+
+	async balanceManagerReferralPoolId(referral: string): Promise<string> {
+		const tx = new Transaction();
+
+		tx.add(this.#ctx.balanceManager.balanceManagerReferralPoolId(referral));
+
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const bytes = res.commandResults![0].returnValues[0].bcs;
+		const poolId = bcs.Address.parse(bytes);
+
+		return normalizeSuiAddress(poolId);
+	}
+
+	async poolReferralMultiplier(poolKey: string, referral: string): Promise<number> {
+		const tx = new Transaction();
+
+		tx.add(this.#ctx.deepBook.poolReferralMultiplier(poolKey, referral));
+
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const bytes = res.commandResults![0].returnValues[0].bcs;
+		const multiplier = Number(bcs.U64.parse(bytes));
+
+		return multiplier / FLOAT_SCALAR;
+	}
+
+	async getBalanceManagerReferralId(managerKey: string, poolKey: string): Promise<string | null> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.balanceManager.getBalanceManagerReferralId(managerKey, poolKey));
+
+		const res = await this.#ctx.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 normalizeSuiAddress(optionId);
+		} catch {
+			return null;
+		}
+	}
+}

package/src/queries/registryQueries.ts

@@ -0,0 +1,185 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { bcs } from '@mysten/sui/bcs';
+import { Transaction } from '@mysten/sui/transactions';
+import { normalizeSuiAddress } from '@mysten/sui/utils';
+
+import { VecSet } from '../types/bcs.js';
+import { FLOAT_SCALAR } from '../utils/config.js';
+import type { QueryContext } from './context.js';
+
+export class RegistryQueries {
+	#ctx: QueryContext;
+
+	constructor(ctx: QueryContext) {
+		this.#ctx = ctx;
+	}
+
+	async isPoolEnabledForMargin(poolKey: string): Promise<boolean> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.marginRegistry.poolEnabled(poolKey));
+
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const bytes = res.commandResults![0].returnValues[0].bcs;
+		return bcs.Bool.parse(bytes);
+	}
+
+	async getMarginManagerIdsForOwner(owner: string): Promise<string[]> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.marginRegistry.getMarginManagerIds(owner));
+
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const bytes = res.commandResults![0].returnValues[0].bcs;
+		const vecSet = VecSet(bcs.Address).parse(bytes);
+		return vecSet.contents.map((id) => normalizeSuiAddress(id));
+	}
+
+	async getBaseMarginPoolId(poolKey: string): Promise<string> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.marginRegistry.baseMarginPoolId(poolKey));
+
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const bytes = res.commandResults![0].returnValues[0].bcs;
+		const id = bcs.Address.parse(bytes);
+		return '0x' + id;
+	}
+
+	async getQuoteMarginPoolId(poolKey: string): Promise<string> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.marginRegistry.quoteMarginPoolId(poolKey));
+
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const bytes = res.commandResults![0].returnValues[0].bcs;
+		const id = bcs.Address.parse(bytes);
+		return '0x' + id;
+	}
+
+	async getMinWithdrawRiskRatio(poolKey: string): Promise<number> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.marginRegistry.minWithdrawRiskRatio(poolKey));
+
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const bytes = res.commandResults![0].returnValues[0].bcs;
+		const ratio = Number(bcs.U64.parse(bytes));
+		return ratio / FLOAT_SCALAR;
+	}
+
+	async getMinBorrowRiskRatio(poolKey: string): Promise<number> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.marginRegistry.minBorrowRiskRatio(poolKey));
+
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const bytes = res.commandResults![0].returnValues[0].bcs;
+		const ratio = Number(bcs.U64.parse(bytes));
+		return ratio / FLOAT_SCALAR;
+	}
+
+	async getLiquidationRiskRatio(poolKey: string): Promise<number> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.marginRegistry.liquidationRiskRatio(poolKey));
+
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const bytes = res.commandResults![0].returnValues[0].bcs;
+		const ratio = Number(bcs.U64.parse(bytes));
+		return ratio / FLOAT_SCALAR;
+	}
+
+	async getTargetLiquidationRiskRatio(poolKey: string): Promise<number> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.marginRegistry.targetLiquidationRiskRatio(poolKey));
+
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const bytes = res.commandResults![0].returnValues[0].bcs;
+		const ratio = Number(bcs.U64.parse(bytes));
+		return ratio / FLOAT_SCALAR;
+	}
+
+	async getUserLiquidationReward(poolKey: string): Promise<number> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.marginRegistry.userLiquidationReward(poolKey));
+
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const bytes = res.commandResults![0].returnValues[0].bcs;
+		const reward = Number(bcs.U64.parse(bytes));
+		return reward / FLOAT_SCALAR;
+	}
+
+	async getPoolLiquidationReward(poolKey: string): Promise<number> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.marginRegistry.poolLiquidationReward(poolKey));
+
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const bytes = res.commandResults![0].returnValues[0].bcs;
+		const reward = Number(bcs.U64.parse(bytes));
+		return reward / FLOAT_SCALAR;
+	}
+
+	async getAllowedMaintainers(): Promise<string[]> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.marginRegistry.allowedMaintainers());
+
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const bytes = res.commandResults![0].returnValues[0].bcs;
+		const vecSet = VecSet(bcs.Address).parse(bytes);
+		return vecSet.contents.map((id) => normalizeSuiAddress(id));
+	}
+
+	async getAllowedPauseCaps(): Promise<string[]> {
+		const tx = new Transaction();
+		tx.add(this.#ctx.marginRegistry.allowedPauseCaps());
+
+		const res = await this.#ctx.client.core.simulateTransaction({
+			transaction: tx,
+			include: { commandResults: true, effects: true },
+		});
+
+		const bytes = res.commandResults![0].returnValues[0].bcs;
+		const vecSet = VecSet(bcs.Address).parse(bytes);
+		return vecSet.contents.map((id) => normalizeSuiAddress(id));
+	}
+}