@haneullabs/deepbook-v3 0.1.0 → 1.2.1

package/dist/client.d.mts

@@ -0,0 +1,238 @@
+import { AccountInfo, BalanceManager, BaseQuantityIn, BaseQuantityOut, BorrowedShares, CanPlaceLimitOrderParams, CanPlaceMarketOrderParams, DecodedOrderId, Level2Range, Level2TicksFromMid, LockedBalances, ManagerBalance, MarginManager, MarginManagerAssets, MarginManagerBalancesResult, MarginManagerDebts, MarginManagerState, OrderDeepRequiredResult, PoolBookParams, PoolDeepPrice, PoolTradeParams, QuantityOut, QuoteQuantityIn, QuoteQuantityOut, ReferralBalances, VaultBalances } from "./types/index.mjs";
+import { CoinMap, DeepbookPackageIds, PoolMap } from "./utils/constants.mjs";
+import { BalanceManagerContract } from "./transactions/balanceManager.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 { MarginLiquidationsContract } from "./transactions/marginLiquidations.mjs";
+import { MarginMaintainerContract } from "./transactions/marginMaintainer.mjs";
+import { MarginManagerContract } from "./transactions/marginManager.mjs";
+import { MarginPoolContract } from "./transactions/marginPool.mjs";
+import { MarginRegistryContract } from "./transactions/marginRegistry.mjs";
+import { MarginTPSLContract } from "./transactions/marginTPSL.mjs";
+import { PoolProxyContract } from "./transactions/poolProxy.mjs";
+import { Transaction } from "@haneullabs/haneul/transactions";
+import { ClientWithCoreApi, HaneulClientRegistration, HaneulClientTypes } from "@haneullabs/haneul/client";
+
+//#region src/client.d.ts
+interface DeepBookCompatibleClient extends ClientWithCoreApi {}
+interface DeepBookOptions<Name = 'deepbook'> {
+  address: string;
+  balanceManagers?: {
+    [key: string]: BalanceManager;
+  };
+  marginManagers?: {
+    [key: string]: MarginManager;
+  };
+  coins?: CoinMap;
+  pools?: PoolMap;
+  adminCap?: string;
+  marginAdminCap?: string;
+  marginMaintainerCap?: string;
+  packageIds?: DeepbookPackageIds;
+  pyth?: {
+    pythStateId: string;
+    wormholeStateId: string;
+  };
+  name?: Name;
+}
+interface DeepBookClientOptions extends DeepBookOptions {
+  client: DeepBookCompatibleClient;
+  network: HaneulClientTypes.Network;
+}
+declare function deepbook<Name extends string = 'deepbook'>({
+  name,
+  ...options
+}: DeepBookOptions<Name>): HaneulClientRegistration<DeepBookCompatibleClient, Name, DeepBookClient>;
+/**
+ * DeepBookClient class for managing DeepBook operations.
+ */
+declare class DeepBookClient {
+  #private;
+  balanceManager: BalanceManagerContract;
+  deepBook: DeepBookContract;
+  deepBookAdmin: DeepBookAdminContract;
+  flashLoans: FlashLoanContract;
+  governance: GovernanceContract;
+  marginAdmin: MarginAdminContract;
+  marginMaintainer: MarginMaintainerContract;
+  marginPool: MarginPoolContract;
+  marginManager: MarginManagerContract;
+  marginRegistry: MarginRegistryContract;
+  marginLiquidations: MarginLiquidationsContract;
+  poolProxy: PoolProxyContract;
+  marginTPSL: MarginTPSLContract;
+  /**
+   * Creates a new DeepBookClient instance
+   */
+  constructor({
+    client,
+    address,
+    network,
+    balanceManagers,
+    marginManagers,
+    coins,
+    pools,
+    adminCap,
+    marginAdminCap,
+    marginMaintainerCap,
+    packageIds,
+    pyth
+  }: DeepBookClientOptions);
+  checkManagerBalance(managerKey: string, coinKey: string): Promise<ManagerBalance>;
+  checkManagerBalanceWithAddress(managerAddress: string, coinKey: string): Promise<ManagerBalance>;
+  checkManagerBalancesWithAddress(managerAddresses: string[], coinKeys: string[]): Promise<Record<string, Record<string, number>>>;
+  getBalanceManagerIds(owner: string): Promise<string[]>;
+  accountExists(poolKey: string, managerKey: string): Promise<boolean>;
+  whitelisted(poolKey: string): Promise<boolean>;
+  vaultBalances(poolKey: string): Promise<VaultBalances>;
+  getPoolIdByAssets(baseType: string, quoteType: string): Promise<string>;
+  midPrice(poolKey: string): Promise<number>;
+  poolTradeParams(poolKey: string): Promise<PoolTradeParams>;
+  poolBookParams(poolKey: string): Promise<PoolBookParams>;
+  stablePool(poolKey: string): Promise<boolean>;
+  registeredPool(poolKey: string): Promise<boolean>;
+  poolTradeParamsNext(poolKey: string): Promise<PoolTradeParams>;
+  quorum(poolKey: string): Promise<number>;
+  poolId(poolKey: string): Promise<string>;
+  canPlaceLimitOrder(params: CanPlaceLimitOrderParams): Promise<boolean>;
+  canPlaceMarketOrder(params: CanPlaceMarketOrderParams): Promise<boolean>;
+  checkMarketOrderParams(poolKey: string, quantity: number | bigint): Promise<boolean>;
+  checkLimitOrderParams(poolKey: string, price: number | bigint, quantity: number | bigint, expireTimestamp: number): Promise<boolean>;
+  getQuoteQuantityOut(poolKey: string, baseQuantity: number | bigint): Promise<QuoteQuantityOut>;
+  getBaseQuantityOut(poolKey: string, quoteQuantity: number | bigint): Promise<BaseQuantityOut>;
+  getQuantityOut(poolKey: string, baseQuantity: number | bigint, quoteQuantity: number | bigint): Promise<QuantityOut>;
+  getQuoteQuantityOutInputFee(poolKey: string, baseQuantity: number | bigint): Promise<QuoteQuantityOut>;
+  getBaseQuantityOutInputFee(poolKey: string, quoteQuantity: number | bigint): Promise<BaseQuantityOut>;
+  getQuantityOutInputFee(poolKey: string, baseQuantity: number | bigint, quoteQuantity: number | bigint): Promise<QuantityOut>;
+  getBaseQuantityIn(poolKey: string, targetQuoteQuantity: number | bigint, payWithDeep: boolean): Promise<BaseQuantityIn>;
+  getQuoteQuantityIn(poolKey: string, targetBaseQuantity: number | bigint, payWithDeep: boolean): Promise<QuoteQuantityIn>;
+  getOrderDeepRequired(poolKey: string, baseQuantity: number | bigint, price: number | bigint): Promise<OrderDeepRequiredResult>;
+  accountOpenOrders(poolKey: string, managerKey: string): Promise<string[]>;
+  getOrder(poolKey: string, orderId: string): Promise<{
+    balance_manager_id: string;
+    order_id: string;
+    client_order_id: string;
+    quantity: string;
+    filled_quantity: string;
+    fee_is_deep: boolean;
+    order_deep_price: {
+      asset_is_base: boolean;
+      deep_per_asset: string;
+    };
+    epoch: string;
+    status: number;
+    expire_timestamp: string;
+  } | null>;
+  getOrderNormalized(poolKey: string, orderId: string): Promise<{
+    quantity: string;
+    filled_quantity: string;
+    order_deep_price: {
+      deep_per_asset: string;
+      asset_is_base: boolean;
+    };
+    isBid: boolean;
+    normalized_price: string;
+    balance_manager_id: string;
+    order_id: string;
+    client_order_id: string;
+    fee_is_deep: boolean;
+    epoch: string;
+    status: number;
+    expire_timestamp: string;
+  } | null>;
+  getOrders(poolKey: string, orderIds: string[]): Promise<{
+    balance_manager_id: string;
+    order_id: string;
+    client_order_id: string;
+    quantity: string;
+    filled_quantity: string;
+    fee_is_deep: boolean;
+    order_deep_price: {
+      asset_is_base: boolean;
+      deep_per_asset: string;
+    };
+    epoch: string;
+    status: number;
+    expire_timestamp: string;
+  }[] | null>;
+  getLevel2Range(poolKey: string, priceLow: number | bigint, priceHigh: number | bigint, isBid: boolean): Promise<Level2Range>;
+  getLevel2TicksFromMid(poolKey: string, ticks: number): Promise<Level2TicksFromMid>;
+  getAccountOrderDetails(poolKey: string, managerKey: string): Promise<[] | {
+    balance_manager_id: string;
+    order_id: string;
+    client_order_id: string;
+    quantity: string;
+    filled_quantity: string;
+    fee_is_deep: boolean;
+    order_deep_price: {
+      asset_is_base: boolean;
+      deep_per_asset: string;
+    };
+    epoch: string;
+    status: number;
+    expire_timestamp: string;
+  }[]>;
+  account(poolKey: string, managerKey: string): Promise<AccountInfo>;
+  lockedBalance(poolKey: string, balanceManagerKey: string): Promise<LockedBalances>;
+  getPoolDeepPrice(poolKey: string): Promise<PoolDeepPrice>;
+  balanceManagerReferralOwner(referral: string): Promise<string>;
+  getPoolReferralBalances(poolKey: string, referral: string): Promise<ReferralBalances>;
+  balanceManagerReferralPoolId(referral: string): Promise<string>;
+  poolReferralMultiplier(poolKey: string, referral: string): Promise<number>;
+  getBalanceManagerReferralId(managerKey: string, poolKey: string): Promise<string | null>;
+  getPriceInfoObject(tx: Transaction, coinKey: string): Promise<string>;
+  getPriceInfoObjects(tx: Transaction, coinKeys: string[]): Promise<Record<string, string>>;
+  getPriceInfoObjectAge(coinKey: string): Promise<number>;
+  getMarginPoolId(coinKey: string): Promise<string>;
+  isDeepbookPoolAllowed(coinKey: string, deepbookPoolId: string): Promise<boolean>;
+  getMarginPoolTotalSupply(coinKey: string, decimals?: number): Promise<string>;
+  getMarginPoolSupplyShares(coinKey: string, decimals?: number): Promise<string>;
+  getMarginPoolTotalBorrow(coinKey: string, decimals?: number): Promise<string>;
+  getMarginPoolBorrowShares(coinKey: string, decimals?: number): Promise<string>;
+  getMarginPoolLastUpdateTimestamp(coinKey: string): Promise<number>;
+  getMarginPoolSupplyCap(coinKey: string, decimals?: number): Promise<string>;
+  getMarginPoolMaxUtilizationRate(coinKey: string): Promise<number>;
+  getMarginPoolProtocolSpread(coinKey: string): Promise<number>;
+  getMarginPoolMinBorrow(coinKey: string, decimals?: number): Promise<string>;
+  getMarginPoolInterestRate(coinKey: string): Promise<number>;
+  getUserSupplyShares(coinKey: string, supplierCapId: string, decimals?: number): Promise<string>;
+  getUserSupplyAmount(coinKey: string, supplierCapId: string, decimals?: number): Promise<string>;
+  getMarginManagerOwner(marginManagerKey: string): Promise<string>;
+  getMarginManagerDeepbookPool(marginManagerKey: string): Promise<string>;
+  getMarginManagerMarginPoolId(marginManagerKey: string): Promise<string | null>;
+  getMarginManagerBorrowedShares(marginManagerKey: string): Promise<BorrowedShares>;
+  getMarginManagerBorrowedBaseShares(marginManagerKey: string): Promise<string>;
+  getMarginManagerBorrowedQuoteShares(marginManagerKey: string): Promise<string>;
+  getMarginManagerHasBaseDebt(marginManagerKey: string): Promise<boolean>;
+  getMarginManagerBalanceManagerId(marginManagerAddress: string): Promise<string>;
+  getMarginManagerAssets(marginManagerKey: string, decimals?: number): Promise<MarginManagerAssets>;
+  getMarginManagerDebts(marginManagerKey: string, decimals?: number): Promise<MarginManagerDebts>;
+  getMarginManagerState(marginManagerKey: string, decimals?: number): Promise<MarginManagerState>;
+  getMarginManagerStates(marginManagers: Record<string, string>, decimals?: number): Promise<Record<string, MarginManagerState>>;
+  getMarginManagerBaseBalance(marginManagerKey: string, decimals?: number): Promise<string>;
+  getMarginManagerQuoteBalance(marginManagerKey: string, decimals?: number): Promise<string>;
+  getMarginManagerDeepBalance(marginManagerKey: string, decimals?: number): Promise<string>;
+  getMarginManagerBalances(marginManagers: Record<string, string>, decimals?: number): Promise<Record<string, MarginManagerBalancesResult>>;
+  getConditionalOrderIds(marginManagerKey: string): Promise<string[]>;
+  getLowestTriggerAbovePrice(marginManagerKey: string): Promise<bigint>;
+  getHighestTriggerBelowPrice(marginManagerKey: string): Promise<bigint>;
+  isPoolEnabledForMargin(poolKey: string): Promise<boolean>;
+  getMarginManagerIdsForOwner(owner: string): Promise<string[]>;
+  getBaseMarginPoolId(poolKey: string): Promise<string>;
+  getQuoteMarginPoolId(poolKey: string): Promise<string>;
+  getMinWithdrawRiskRatio(poolKey: string): Promise<number>;
+  getMinBorrowRiskRatio(poolKey: string): Promise<number>;
+  getLiquidationRiskRatio(poolKey: string): Promise<number>;
+  getTargetLiquidationRiskRatio(poolKey: string): Promise<number>;
+  getUserLiquidationReward(poolKey: string): Promise<number>;
+  getPoolLiquidationReward(poolKey: string): Promise<number>;
+  getAllowedMaintainers(): Promise<string[]>;
+  getAllowedPauseCaps(): Promise<string[]>;
+  decodeOrderId(encodedOrderId: bigint): DecodedOrderId;
+}
+//#endregion
+export { DeepBookClient, DeepBookClientOptions, DeepBookCompatibleClient, DeepBookOptions, deepbook };
+//# sourceMappingURL=client.d.mts.map

package/dist/client.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.mts","names":[],"sources":["../src/client.ts"],"mappings":"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"}

package/dist/client.mjs

@@ -0,0 +1,397 @@
+import { BalanceManagerContract } from "./transactions/balanceManager.mjs";
+import { DeepBookConfig } from "./utils/config.mjs";
+import { AccountQueries } from "./queries/accountQueries.mjs";
+import { BalanceManagerQueries } from "./queries/balanceManagerQueries.mjs";
+import { MarginManagerQueries } from "./queries/marginManagerQueries.mjs";
+import { MarginPoolQueries } from "./queries/marginPoolQueries.mjs";
+import { OrderQueries } from "./queries/orderQueries.mjs";
+import { PoolQueries } from "./queries/poolQueries.mjs";
+import { PriceFeedQueries } from "./queries/priceFeedQueries.mjs";
+import { QuantityQueries } from "./queries/quantityQueries.mjs";
+import { ReferralQueries } from "./queries/referralQueries.mjs";
+import { RegistryQueries } from "./queries/registryQueries.mjs";
+import { TPSLQueries } from "./queries/tpslQueries.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 { MarginLiquidationsContract } from "./transactions/marginLiquidations.mjs";
+import { MarginMaintainerContract } from "./transactions/marginMaintainer.mjs";
+import { MarginManagerContract } from "./transactions/marginManager.mjs";
+import { MarginPoolContract } from "./transactions/marginPool.mjs";
+import { MarginRegistryContract } from "./transactions/marginRegistry.mjs";
+import { MarginTPSLContract } from "./transactions/marginTPSL.mjs";
+import { PoolProxyContract } from "./transactions/poolProxy.mjs";
+import { normalizeHaneulAddress } from "@haneullabs/haneul/utils";
+
+//#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 {
+	#balanceManagerQueries;
+	#poolQueries;
+	#quantityQueries;
+	#orderQueries;
+	#accountQueries;
+	#referralQueries;
+	#priceFeedQueries;
+	#marginPoolQueries;
+	#marginManagerQueries;
+	#tpslQueries;
+	#registryQueries;
+	/**
+	* Creates a new DeepBookClient instance
+	*/
+	constructor({ client, address, network, balanceManagers, marginManagers, coins, pools, adminCap, marginAdminCap, marginMaintainerCap, packageIds, pyth }) {
+		const normalizedAddress = normalizeHaneulAddress(address);
+		const config = new DeepBookConfig({
+			address: normalizedAddress,
+			network,
+			balanceManagers,
+			marginManagers,
+			coins,
+			pools,
+			adminCap,
+			marginAdminCap,
+			marginMaintainerCap,
+			packageIds,
+			pyth
+		});
+		this.balanceManager = new BalanceManagerContract(config);
+		this.deepBook = new DeepBookContract(config);
+		this.deepBookAdmin = new DeepBookAdminContract(config);
+		this.flashLoans = new FlashLoanContract(config);
+		this.governance = new GovernanceContract(config);
+		this.marginAdmin = new MarginAdminContract(config);
+		this.marginMaintainer = new MarginMaintainerContract(config);
+		this.marginPool = new MarginPoolContract(config);
+		this.marginManager = new MarginManagerContract(config);
+		this.marginRegistry = new MarginRegistryContract(config);
+		this.marginLiquidations = new MarginLiquidationsContract(config);
+		this.poolProxy = new PoolProxyContract(config);
+		this.marginTPSL = new MarginTPSLContract(config);
+		const ctx = {
+			client,
+			config,
+			address: normalizedAddress,
+			balanceManager: this.balanceManager,
+			deepBook: this.deepBook,
+			marginManager: this.marginManager,
+			marginPool: this.marginPool,
+			marginRegistry: this.marginRegistry,
+			marginTPSL: this.marginTPSL
+		};
+		this.#balanceManagerQueries = new BalanceManagerQueries(ctx);
+		this.#poolQueries = new PoolQueries(ctx);
+		this.#quantityQueries = new QuantityQueries(ctx);
+		this.#orderQueries = new OrderQueries(ctx);
+		this.#accountQueries = new AccountQueries(ctx);
+		this.#referralQueries = new ReferralQueries(ctx);
+		this.#priceFeedQueries = new PriceFeedQueries(ctx);
+		this.#marginPoolQueries = new MarginPoolQueries(ctx);
+		this.#marginManagerQueries = new MarginManagerQueries(ctx);
+		this.#tpslQueries = new TPSLQueries(ctx);
+		this.#registryQueries = new RegistryQueries(ctx);
+	}
+	checkManagerBalance(managerKey, coinKey) {
+		return this.#balanceManagerQueries.checkManagerBalance(managerKey, coinKey);
+	}
+	checkManagerBalanceWithAddress(managerAddress, coinKey) {
+		return this.#balanceManagerQueries.checkManagerBalanceWithAddress(managerAddress, coinKey);
+	}
+	checkManagerBalancesWithAddress(managerAddresses, coinKeys) {
+		return this.#balanceManagerQueries.checkManagerBalancesWithAddress(managerAddresses, coinKeys);
+	}
+	getBalanceManagerIds(owner) {
+		return this.#balanceManagerQueries.getBalanceManagerIds(owner);
+	}
+	accountExists(poolKey, managerKey) {
+		return this.#balanceManagerQueries.accountExists(poolKey, managerKey);
+	}
+	whitelisted(poolKey) {
+		return this.#poolQueries.whitelisted(poolKey);
+	}
+	vaultBalances(poolKey) {
+		return this.#poolQueries.vaultBalances(poolKey);
+	}
+	getPoolIdByAssets(baseType, quoteType) {
+		return this.#poolQueries.getPoolIdByAssets(baseType, quoteType);
+	}
+	midPrice(poolKey) {
+		return this.#poolQueries.midPrice(poolKey);
+	}
+	poolTradeParams(poolKey) {
+		return this.#poolQueries.poolTradeParams(poolKey);
+	}
+	poolBookParams(poolKey) {
+		return this.#poolQueries.poolBookParams(poolKey);
+	}
+	stablePool(poolKey) {
+		return this.#poolQueries.stablePool(poolKey);
+	}
+	registeredPool(poolKey) {
+		return this.#poolQueries.registeredPool(poolKey);
+	}
+	poolTradeParamsNext(poolKey) {
+		return this.#poolQueries.poolTradeParamsNext(poolKey);
+	}
+	quorum(poolKey) {
+		return this.#poolQueries.quorum(poolKey);
+	}
+	poolId(poolKey) {
+		return this.#poolQueries.poolId(poolKey);
+	}
+	canPlaceLimitOrder(params) {
+		return this.#poolQueries.canPlaceLimitOrder(params);
+	}
+	canPlaceMarketOrder(params) {
+		return this.#poolQueries.canPlaceMarketOrder(params);
+	}
+	checkMarketOrderParams(poolKey, quantity) {
+		return this.#poolQueries.checkMarketOrderParams(poolKey, quantity);
+	}
+	checkLimitOrderParams(poolKey, price, quantity, expireTimestamp) {
+		return this.#poolQueries.checkLimitOrderParams(poolKey, price, quantity, expireTimestamp);
+	}
+	getQuoteQuantityOut(poolKey, baseQuantity) {
+		return this.#quantityQueries.getQuoteQuantityOut(poolKey, baseQuantity);
+	}
+	getBaseQuantityOut(poolKey, quoteQuantity) {
+		return this.#quantityQueries.getBaseQuantityOut(poolKey, quoteQuantity);
+	}
+	getQuantityOut(poolKey, baseQuantity, quoteQuantity) {
+		return this.#quantityQueries.getQuantityOut(poolKey, baseQuantity, quoteQuantity);
+	}
+	getQuoteQuantityOutInputFee(poolKey, baseQuantity) {
+		return this.#quantityQueries.getQuoteQuantityOutInputFee(poolKey, baseQuantity);
+	}
+	getBaseQuantityOutInputFee(poolKey, quoteQuantity) {
+		return this.#quantityQueries.getBaseQuantityOutInputFee(poolKey, quoteQuantity);
+	}
+	getQuantityOutInputFee(poolKey, baseQuantity, quoteQuantity) {
+		return this.#quantityQueries.getQuantityOutInputFee(poolKey, baseQuantity, quoteQuantity);
+	}
+	getBaseQuantityIn(poolKey, targetQuoteQuantity, payWithDeep) {
+		return this.#quantityQueries.getBaseQuantityIn(poolKey, targetQuoteQuantity, payWithDeep);
+	}
+	getQuoteQuantityIn(poolKey, targetBaseQuantity, payWithDeep) {
+		return this.#quantityQueries.getQuoteQuantityIn(poolKey, targetBaseQuantity, payWithDeep);
+	}
+	getOrderDeepRequired(poolKey, baseQuantity, price) {
+		return this.#quantityQueries.getOrderDeepRequired(poolKey, baseQuantity, price);
+	}
+	accountOpenOrders(poolKey, managerKey) {
+		return this.#orderQueries.accountOpenOrders(poolKey, managerKey);
+	}
+	getOrder(poolKey, orderId) {
+		return this.#orderQueries.getOrder(poolKey, orderId);
+	}
+	getOrderNormalized(poolKey, orderId) {
+		return this.#orderQueries.getOrderNormalized(poolKey, orderId);
+	}
+	getOrders(poolKey, orderIds) {
+		return this.#orderQueries.getOrders(poolKey, orderIds);
+	}
+	getLevel2Range(poolKey, priceLow, priceHigh, isBid) {
+		return this.#orderQueries.getLevel2Range(poolKey, priceLow, priceHigh, isBid);
+	}
+	getLevel2TicksFromMid(poolKey, ticks) {
+		return this.#orderQueries.getLevel2TicksFromMid(poolKey, ticks);
+	}
+	getAccountOrderDetails(poolKey, managerKey) {
+		return this.#orderQueries.getAccountOrderDetails(poolKey, managerKey);
+	}
+	account(poolKey, managerKey) {
+		return this.#accountQueries.account(poolKey, managerKey);
+	}
+	lockedBalance(poolKey, balanceManagerKey) {
+		return this.#accountQueries.lockedBalance(poolKey, balanceManagerKey);
+	}
+	getPoolDeepPrice(poolKey) {
+		return this.#accountQueries.getPoolDeepPrice(poolKey);
+	}
+	balanceManagerReferralOwner(referral) {
+		return this.#referralQueries.balanceManagerReferralOwner(referral);
+	}
+	getPoolReferralBalances(poolKey, referral) {
+		return this.#referralQueries.getPoolReferralBalances(poolKey, referral);
+	}
+	balanceManagerReferralPoolId(referral) {
+		return this.#referralQueries.balanceManagerReferralPoolId(referral);
+	}
+	poolReferralMultiplier(poolKey, referral) {
+		return this.#referralQueries.poolReferralMultiplier(poolKey, referral);
+	}
+	getBalanceManagerReferralId(managerKey, poolKey) {
+		return this.#referralQueries.getBalanceManagerReferralId(managerKey, poolKey);
+	}
+	getPriceInfoObject(tx, coinKey) {
+		return this.#priceFeedQueries.getPriceInfoObject(tx, coinKey);
+	}
+	getPriceInfoObjects(tx, coinKeys) {
+		return this.#priceFeedQueries.getPriceInfoObjects(tx, coinKeys);
+	}
+	getPriceInfoObjectAge(coinKey) {
+		return this.#priceFeedQueries.getPriceInfoObjectAge(coinKey);
+	}
+	getMarginPoolId(coinKey) {
+		return this.#marginPoolQueries.getMarginPoolId(coinKey);
+	}
+	isDeepbookPoolAllowed(coinKey, deepbookPoolId) {
+		return this.#marginPoolQueries.isDeepbookPoolAllowed(coinKey, deepbookPoolId);
+	}
+	getMarginPoolTotalSupply(coinKey, decimals = 6) {
+		return this.#marginPoolQueries.getMarginPoolTotalSupply(coinKey, decimals);
+	}
+	getMarginPoolSupplyShares(coinKey, decimals = 6) {
+		return this.#marginPoolQueries.getMarginPoolSupplyShares(coinKey, decimals);
+	}
+	getMarginPoolTotalBorrow(coinKey, decimals = 6) {
+		return this.#marginPoolQueries.getMarginPoolTotalBorrow(coinKey, decimals);
+	}
+	getMarginPoolBorrowShares(coinKey, decimals = 6) {
+		return this.#marginPoolQueries.getMarginPoolBorrowShares(coinKey, decimals);
+	}
+	getMarginPoolLastUpdateTimestamp(coinKey) {
+		return this.#marginPoolQueries.getMarginPoolLastUpdateTimestamp(coinKey);
+	}
+	getMarginPoolSupplyCap(coinKey, decimals = 6) {
+		return this.#marginPoolQueries.getMarginPoolSupplyCap(coinKey, decimals);
+	}
+	getMarginPoolMaxUtilizationRate(coinKey) {
+		return this.#marginPoolQueries.getMarginPoolMaxUtilizationRate(coinKey);
+	}
+	getMarginPoolProtocolSpread(coinKey) {
+		return this.#marginPoolQueries.getMarginPoolProtocolSpread(coinKey);
+	}
+	getMarginPoolMinBorrow(coinKey, decimals = 6) {
+		return this.#marginPoolQueries.getMarginPoolMinBorrow(coinKey, decimals);
+	}
+	getMarginPoolInterestRate(coinKey) {
+		return this.#marginPoolQueries.getMarginPoolInterestRate(coinKey);
+	}
+	getUserSupplyShares(coinKey, supplierCapId, decimals = 6) {
+		return this.#marginPoolQueries.getUserSupplyShares(coinKey, supplierCapId, decimals);
+	}
+	getUserSupplyAmount(coinKey, supplierCapId, decimals = 6) {
+		return this.#marginPoolQueries.getUserSupplyAmount(coinKey, supplierCapId, decimals);
+	}
+	getMarginManagerOwner(marginManagerKey) {
+		return this.#marginManagerQueries.getMarginManagerOwner(marginManagerKey);
+	}
+	getMarginManagerDeepbookPool(marginManagerKey) {
+		return this.#marginManagerQueries.getMarginManagerDeepbookPool(marginManagerKey);
+	}
+	getMarginManagerMarginPoolId(marginManagerKey) {
+		return this.#marginManagerQueries.getMarginManagerMarginPoolId(marginManagerKey);
+	}
+	getMarginManagerBorrowedShares(marginManagerKey) {
+		return this.#marginManagerQueries.getMarginManagerBorrowedShares(marginManagerKey);
+	}
+	getMarginManagerBorrowedBaseShares(marginManagerKey) {
+		return this.#marginManagerQueries.getMarginManagerBorrowedBaseShares(marginManagerKey);
+	}
+	getMarginManagerBorrowedQuoteShares(marginManagerKey) {
+		return this.#marginManagerQueries.getMarginManagerBorrowedQuoteShares(marginManagerKey);
+	}
+	getMarginManagerHasBaseDebt(marginManagerKey) {
+		return this.#marginManagerQueries.getMarginManagerHasBaseDebt(marginManagerKey);
+	}
+	getMarginManagerBalanceManagerId(marginManagerAddress) {
+		return this.#marginManagerQueries.getMarginManagerBalanceManagerId(marginManagerAddress);
+	}
+	getMarginManagerAssets(marginManagerKey, decimals = 6) {
+		return this.#marginManagerQueries.getMarginManagerAssets(marginManagerKey, decimals);
+	}
+	getMarginManagerDebts(marginManagerKey, decimals = 6) {
+		return this.#marginManagerQueries.getMarginManagerDebts(marginManagerKey, decimals);
+	}
+	getMarginManagerState(marginManagerKey, decimals = 6) {
+		return this.#marginManagerQueries.getMarginManagerState(marginManagerKey, decimals);
+	}
+	getMarginManagerStates(marginManagers, decimals = 6) {
+		return this.#marginManagerQueries.getMarginManagerStates(marginManagers, decimals);
+	}
+	getMarginManagerBaseBalance(marginManagerKey, decimals = 9) {
+		return this.#marginManagerQueries.getMarginManagerBaseBalance(marginManagerKey, decimals);
+	}
+	getMarginManagerQuoteBalance(marginManagerKey, decimals = 9) {
+		return this.#marginManagerQueries.getMarginManagerQuoteBalance(marginManagerKey, decimals);
+	}
+	getMarginManagerDeepBalance(marginManagerKey, decimals = 6) {
+		return this.#marginManagerQueries.getMarginManagerDeepBalance(marginManagerKey, decimals);
+	}
+	getMarginManagerBalances(marginManagers, decimals = 9) {
+		return this.#marginManagerQueries.getMarginManagerBalances(marginManagers, decimals);
+	}
+	getConditionalOrderIds(marginManagerKey) {
+		return this.#tpslQueries.getConditionalOrderIds(marginManagerKey);
+	}
+	getLowestTriggerAbovePrice(marginManagerKey) {
+		return this.#tpslQueries.getLowestTriggerAbovePrice(marginManagerKey);
+	}
+	getHighestTriggerBelowPrice(marginManagerKey) {
+		return this.#tpslQueries.getHighestTriggerBelowPrice(marginManagerKey);
+	}
+	isPoolEnabledForMargin(poolKey) {
+		return this.#registryQueries.isPoolEnabledForMargin(poolKey);
+	}
+	getMarginManagerIdsForOwner(owner) {
+		return this.#registryQueries.getMarginManagerIdsForOwner(owner);
+	}
+	getBaseMarginPoolId(poolKey) {
+		return this.#registryQueries.getBaseMarginPoolId(poolKey);
+	}
+	getQuoteMarginPoolId(poolKey) {
+		return this.#registryQueries.getQuoteMarginPoolId(poolKey);
+	}
+	getMinWithdrawRiskRatio(poolKey) {
+		return this.#registryQueries.getMinWithdrawRiskRatio(poolKey);
+	}
+	getMinBorrowRiskRatio(poolKey) {
+		return this.#registryQueries.getMinBorrowRiskRatio(poolKey);
+	}
+	getLiquidationRiskRatio(poolKey) {
+		return this.#registryQueries.getLiquidationRiskRatio(poolKey);
+	}
+	getTargetLiquidationRiskRatio(poolKey) {
+		return this.#registryQueries.getTargetLiquidationRiskRatio(poolKey);
+	}
+	getUserLiquidationReward(poolKey) {
+		return this.#registryQueries.getUserLiquidationReward(poolKey);
+	}
+	getPoolLiquidationReward(poolKey) {
+		return this.#registryQueries.getPoolLiquidationReward(poolKey);
+	}
+	getAllowedMaintainers() {
+		return this.#registryQueries.getAllowedMaintainers();
+	}
+	getAllowedPauseCaps() {
+		return this.#registryQueries.getAllowedPauseCaps();
+	}
+	decodeOrderId(encodedOrderId) {
+		return {
+			isBid: encodedOrderId >> 127n === 0n,
+			price: Number(encodedOrderId >> 64n & (1n << 63n) - 1n),
+			orderId: Number(encodedOrderId & (1n << 64n) - 1n)
+		};
+	}
+};
+
+//#endregion
+export { DeepBookClient, deepbook };
+//# sourceMappingURL=client.mjs.map