@mysten/deepbook-v3 1.5.8 → 1.6.2

package/dist/contracts/deepbook/pool.mjs

@@ -0,0 +1,1739 @@
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.mjs";
+import { VecSet } from "./deps/sui/vec_set.mjs";
+import { DeepPrice } from "./deep_price.mjs";
+import { Versioned } from "./deps/sui/versioned.mjs";
+import { Book } from "./book.mjs";
+import { State } from "./state.mjs";
+import { Balance } from "./deps/sui/balance.mjs";
+import { Vault } from "./vault.mjs";
+import { bcs } from "@mysten/sui/bcs";
+
+//#region src/contracts/deepbook/pool.ts
+/**************************************************************
+* THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+**************************************************************/
+/** Public-facing interface for the package. */
+const $moduleName = "@deepbook/core::pool";
+const Pool = new MoveStruct({
+	name: `${$moduleName}::Pool<phantom BaseAsset, phantom QuoteAsset>`,
+	fields: {
+		id: bcs.Address,
+		inner: Versioned
+	}
+});
+const PoolInner = new MoveStruct({
+	name: `${$moduleName}::PoolInner<phantom BaseAsset, phantom QuoteAsset>`,
+	fields: {
+		allowed_versions: VecSet(bcs.u64()),
+		pool_id: bcs.Address,
+		book: Book,
+		state: State,
+		vault: Vault,
+		deep_price: DeepPrice,
+		registered_pool: bcs.bool()
+	}
+});
+const PoolCreated = new MoveStruct({
+	name: `${$moduleName}::PoolCreated<phantom BaseAsset, phantom QuoteAsset>`,
+	fields: {
+		pool_id: bcs.Address,
+		taker_fee: bcs.u64(),
+		maker_fee: bcs.u64(),
+		tick_size: bcs.u64(),
+		lot_size: bcs.u64(),
+		min_size: bcs.u64(),
+		whitelisted_pool: bcs.bool(),
+		treasury_address: bcs.Address
+	}
+});
+const BookParamsUpdated = new MoveStruct({
+	name: `${$moduleName}::BookParamsUpdated<phantom BaseAsset, phantom QuoteAsset>`,
+	fields: {
+		pool_id: bcs.Address,
+		tick_size: bcs.u64(),
+		lot_size: bcs.u64(),
+		min_size: bcs.u64(),
+		timestamp: bcs.u64()
+	}
+});
+const DeepBurned = new MoveStruct({
+	name: `${$moduleName}::DeepBurned<phantom BaseAsset, phantom QuoteAsset>`,
+	fields: {
+		pool_id: bcs.Address,
+		deep_burned: bcs.u64()
+	}
+});
+const ReferralRewards = new MoveStruct({
+	name: `${$moduleName}::ReferralRewards<phantom BaseAsset, phantom QuoteAsset>`,
+	fields: {
+		multiplier: bcs.u64(),
+		base: Balance,
+		quote: Balance,
+		deep: Balance
+	}
+});
+const ReferralClaimedEvent = new MoveStruct({
+	name: `${$moduleName}::ReferralClaimedEvent<phantom BaseAsset, phantom QuoteAsset>`,
+	fields: {
+		referral_id: bcs.Address,
+		owner: bcs.Address,
+		base_amount: bcs.u64(),
+		quote_amount: bcs.u64(),
+		deep_amount: bcs.u64()
+	}
+});
+const ReferralClaimed = new MoveStruct({
+	name: `${$moduleName}::ReferralClaimed`,
+	fields: {
+		pool_id: bcs.Address,
+		referral_id: bcs.Address,
+		owner: bcs.Address,
+		base_amount: bcs.u64(),
+		quote_amount: bcs.u64(),
+		deep_amount: bcs.u64()
+	}
+});
+const ReferralFeeEvent = new MoveStruct({
+	name: `${$moduleName}::ReferralFeeEvent`,
+	fields: {
+		pool_id: bcs.Address,
+		referral_id: bcs.Address,
+		base_fee: bcs.u64(),
+		quote_fee: bcs.u64(),
+		deep_fee: bcs.u64()
+	}
+});
+/**
+* Create a new pool. The pool is registered in the registry. Checks are performed
+* to ensure the tick size, lot size, and min size are valid. The creation fee is
+* transferred to the treasury address. Returns the id of the pool created
+*/
+function createPermissionlessPool(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		"u64",
+		"u64",
+		"u64",
+		null
+	];
+	const parameterNames = [
+		"registry",
+		"tickSize",
+		"lotSize",
+		"minSize",
+		"creationFee"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "create_permissionless_pool",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Place a limit order. Quantity is in base asset terms. For current version
+* pay_with_deep must be true, so the fee will be paid with DEEP tokens.
+*/
+function placeLimitOrder(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		"u64",
+		"u8",
+		"u8",
+		"u64",
+		"u64",
+		"bool",
+		"bool",
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"self",
+		"balanceManager",
+		"tradeProof",
+		"clientOrderId",
+		"orderType",
+		"selfMatchingOption",
+		"price",
+		"quantity",
+		"isBid",
+		"payWithDeep",
+		"expireTimestamp"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "place_limit_order",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Place a market order. Quantity is in base asset terms. Calls place_limit_order
+* with a price of MAX_PRICE for bids and MIN_PRICE for asks. Any quantity not
+* filled is cancelled.
+*/
+function placeMarketOrder(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		"u64",
+		"u8",
+		"u64",
+		"bool",
+		"bool",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"self",
+		"balanceManager",
+		"tradeProof",
+		"clientOrderId",
+		"selfMatchingOption",
+		"quantity",
+		"isBid",
+		"payWithDeep"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "place_market_order",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Swap exact base quantity without needing a `balance_manager`. DEEP quantity can
+* be overestimated. Returns three `Coin` objects: base, quote, and deep. Some base
+* quantity may be left over, if the input quantity is not divisible by lot size.
+*/
+function swapExactBaseForQuote(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"self",
+		"baseIn",
+		"deepIn",
+		"minQuoteOut"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "swap_exact_base_for_quote",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Swap exact base for quote with a `balance_manager`. Assumes fees are paid in
+* DEEP. Assumes balance manager has enough DEEP for fees.
+*/
+function swapExactBaseForQuoteWithManager(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"self",
+		"balanceManager",
+		"tradeCap",
+		"depositCap",
+		"withdrawCap",
+		"baseIn",
+		"minQuoteOut"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "swap_exact_base_for_quote_with_manager",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Swap exact quote quantity without needing a `balance_manager`. DEEP quantity can
+* be overestimated. Returns three `Coin` objects: base, quote, and deep. Some
+* quote quantity may be left over if the input quantity is not divisible by lot
+* size.
+*/
+function swapExactQuoteForBase(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"self",
+		"quoteIn",
+		"deepIn",
+		"minBaseOut"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "swap_exact_quote_for_base",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Swap exact quote for base with a `balance_manager`. Assumes fees are paid in
+* DEEP. Assumes balance manager has enough DEEP for fees.
+*/
+function swapExactQuoteForBaseWithManager(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"self",
+		"balanceManager",
+		"tradeCap",
+		"depositCap",
+		"withdrawCap",
+		"quoteIn",
+		"minBaseOut"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "swap_exact_quote_for_base_with_manager",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/** Swap exact quantity without needing a balance_manager. */
+function swapExactQuantity(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		null,
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"self",
+		"baseIn",
+		"quoteIn",
+		"deepIn",
+		"minOut"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "swap_exact_quantity",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Swap exact quantity with a `balance_manager`. Assumes fees are paid in DEEP.
+* Assumes balance manager has enough DEEP for fees.
+*/
+function swapExactQuantityWithManager(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"self",
+		"balanceManager",
+		"tradeCap",
+		"depositCap",
+		"withdrawCap",
+		"baseIn",
+		"quoteIn",
+		"minOut"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "swap_exact_quantity_with_manager",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Modifies an order given order_id and new_quantity. New quantity must be less
+* than the original quantity and more than the filled quantity. Order must not
+* have already expired.
+*/
+function modifyOrder(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		"u128",
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"self",
+		"balanceManager",
+		"tradeProof",
+		"orderId",
+		"newQuantity"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "modify_order",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Cancel an order. The order must be owned by the balance_manager. The order is
+* removed from the book and the balance_manager's open orders. The
+* balance_manager's balance is updated with the order's remaining quantity. Order
+* canceled event is emitted.
+*/
+function cancelOrder(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		"u128",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"self",
+		"balanceManager",
+		"tradeProof",
+		"orderId"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "cancel_order",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Cancel multiple orders within a vector. The orders must be owned by the
+* balance_manager. The orders are removed from the book and the balance_manager's
+* open orders. Order canceled events are emitted. If any order fails to cancel, no
+* orders will be cancelled.
+*/
+function cancelOrders(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		"vector<u128>",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"self",
+		"balanceManager",
+		"tradeProof",
+		"orderIds"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "cancel_orders",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Cancel a single order, no-op if the order_id is not currently in the
+* balance_manager's open orders (e.g. already filled, cancelled, or not owned by
+* this balance_manager). If the order is present, it must be owned by the
+* balance_manager. On a successful cancel the order is removed from the book and
+* the balance_manager's open orders, and an order canceled event is emitted.
+*/
+function cancelLiveOrder(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		"u128",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"self",
+		"balanceManager",
+		"tradeProof",
+		"orderId"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "cancel_live_order",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Cancel multiple orders within a vector, skipping any order_id that is not
+* currently in the balance_manager's open orders (e.g. already filled, cancelled,
+* or not owned by this balance_manager). Orders that are present must be owned by
+* the balance_manager. The live orders are removed from the book and the
+* balance_manager's open orders. Order canceled events are emitted for each
+* cancelled order.
+*/
+function cancelLiveOrders(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		"vector<u128>",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"self",
+		"balanceManager",
+		"tradeProof",
+		"orderIds"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "cancel_live_orders",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/** Cancel all open orders placed by the balance manager in the pool. */
+function cancelAllOrders(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"self",
+		"balanceManager",
+		"tradeProof"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "cancel_all_orders",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/** Withdraw settled amounts to the `balance_manager`. */
+function withdrawSettledAmounts(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		null
+	];
+	const parameterNames = [
+		"self",
+		"balanceManager",
+		"tradeProof"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "withdraw_settled_amounts",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/** Withdraw settled amounts permissionlessly to the `balance_manager`. */
+function withdrawSettledAmountsPermissionless(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null, null];
+	const parameterNames = ["self", "balanceManager"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "withdraw_settled_amounts_permissionless",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Stake DEEP tokens to the pool. The balance_manager must have enough DEEP tokens.
+* The balance_manager's data is updated with the staked amount.
+*/
+function stake(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		"u64"
+	];
+	const parameterNames = [
+		"self",
+		"balanceManager",
+		"tradeProof",
+		"amount"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "stake",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Unstake DEEP tokens from the pool. The balance_manager must have enough staked
+* DEEP tokens. The balance_manager's data is updated with the unstaked amount.
+* Balance is transferred to the balance_manager immediately.
+*/
+function unstake(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		null
+	];
+	const parameterNames = [
+		"self",
+		"balanceManager",
+		"tradeProof"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "unstake",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Submit a proposal to change the taker fee, maker fee, and stake required. The
+* balance_manager must have enough staked DEEP tokens to participate. Each
+* balance_manager can only submit one proposal per epoch. If the maximum proposal
+* is reached, the proposal with the lowest vote is removed. If the balance_manager
+* has less voting power than the lowest voted proposal, the proposal is not added.
+*/
+function submitProposal(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		"u64",
+		"u64",
+		"u64"
+	];
+	const parameterNames = [
+		"self",
+		"balanceManager",
+		"tradeProof",
+		"takerFee",
+		"makerFee",
+		"stakeRequired"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "submit_proposal",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Vote on a proposal. The balance_manager must have enough staked DEEP tokens to
+* participate. Full voting power of the balance_manager is used. Voting for a new
+* proposal will remove the vote from the previous proposal.
+*/
+function vote(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		null,
+		"0x2::object::ID"
+	];
+	const parameterNames = [
+		"self",
+		"balanceManager",
+		"tradeProof",
+		"proposalId"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "vote",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Claim the rewards for the balance_manager. The balance_manager must have rewards
+* to claim. The balance_manager's data is updated with the claimed rewards.
+*/
+function claimRebates(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		null
+	];
+	const parameterNames = [
+		"self",
+		"balanceManager",
+		"tradeProof"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "claim_rebates",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Borrow base assets from the Pool. A hot potato is returned, forcing the borrower
+* to return the assets within the same transaction.
+*/
+function borrowFlashloanBase(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null, "u64"];
+	const parameterNames = ["self", "baseAmount"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "borrow_flashloan_base",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Borrow quote assets from the Pool. A hot potato is returned, forcing the
+* borrower to return the assets within the same transaction.
+*/
+function borrowFlashloanQuote(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null, "u64"];
+	const parameterNames = ["self", "quoteAmount"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "borrow_flashloan_quote",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Return the flashloaned base assets to the Pool. FlashLoan object will only be
+* unwrapped if the assets are returned, otherwise the transaction will fail.
+*/
+function returnFlashloanBase(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		null
+	];
+	const parameterNames = [
+		"self",
+		"coin",
+		"flashLoan"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "return_flashloan_base",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Return the flashloaned quote assets to the Pool. FlashLoan object will only be
+* unwrapped if the assets are returned, otherwise the transaction will fail.
+*/
+function returnFlashloanQuote(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		null
+	];
+	const parameterNames = [
+		"self",
+		"coin",
+		"flashLoan"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "return_flashloan_quote",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Adds a price point along with a timestamp to the deep price. Allows for the
+* calculation of deep price per base asset.
+*/
+function addDeepPricePoint(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		"0x2::clock::Clock"
+	];
+	const parameterNames = ["targetPool", "referencePool"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "add_deep_price_point",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/** Burns DEEP tokens from the pool. Amount to burn is within history */
+function burnDeep(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null, null];
+	const parameterNames = ["self", "treasuryCap"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "burn_deep",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/** Mint a DeepBookReferral and set the additional bps for the referral. */
+function mintReferral(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null, "u64"];
+	const parameterNames = ["self", "multiplier"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "mint_referral",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/** Update the multiplier for the referral. */
+function updatePoolReferralMultiplier(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		"u64"
+	];
+	const parameterNames = [
+		"self",
+		"referral",
+		"multiplier"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "update_pool_referral_multiplier",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/** Claim the rewards for the referral. */
+function claimPoolReferralRewards(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null, null];
+	const parameterNames = ["self", "referral"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "claim_pool_referral_rewards",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Create a new pool. The pool is registered in the registry. Checks are performed
+* to ensure the tick size, lot size, and min size are valid. Returns the id of the
+* pool created
+*/
+function createPoolAdmin(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		"u64",
+		"u64",
+		"u64",
+		"bool",
+		"bool",
+		null
+	];
+	const parameterNames = [
+		"registry",
+		"tickSize",
+		"lotSize",
+		"minSize",
+		"whitelistedPool",
+		"stablePool",
+		"Cap"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "create_pool_admin",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/** Unregister a pool in case it needs to be redeployed. */
+function unregisterPoolAdmin(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		null
+	];
+	const parameterNames = [
+		"self",
+		"registry",
+		"Cap"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "unregister_pool_admin",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Takes the registry and updates the allowed version within pool Only admin can
+* update the allowed versions This function does not have version restrictions
+*/
+function updateAllowedVersions(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		null
+	];
+	const parameterNames = [
+		"self",
+		"registry",
+		"Cap"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "update_allowed_versions",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Takes the registry and updates the allowed version within pool Permissionless
+* equivalent of `update_allowed_versions` This function does not have version
+* restrictions
+*/
+function updatePoolAllowedVersions(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null, null];
+	const parameterNames = ["self", "registry"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "update_pool_allowed_versions",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/** Adjust the tick size of the pool. Only admin can adjust the tick size. */
+function adjustTickSizeAdmin(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		"u64",
+		null,
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"self",
+		"newTickSize",
+		"Cap"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "adjust_tick_size_admin",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Adjust and lot size and min size of the pool. New lot size must be smaller than
+* current lot size. Only admin can adjust the min size and lot size.
+*/
+function adjustMinLotSizeAdmin(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		"u64",
+		"u64",
+		null,
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"self",
+		"newLotSize",
+		"newMinSize",
+		"Cap"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "adjust_min_lot_size_admin",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Enable the EWMA state for the pool. This allows the pool to use the EWMA state
+* for volatility calculations and additional taker fees.
+*/
+function enableEwmaState(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		"bool",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"self",
+		"Cap",
+		"enable"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "enable_ewma_state",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/** Set the EWMA parameters for the pool. Only admin can set the parameters. */
+function setEwmaParams(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		"u64",
+		"u64",
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"self",
+		"Cap",
+		"alpha",
+		"zScoreThreshold",
+		"additionalTakerFee"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "set_ewma_params",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/** Accessor to check if the pool is whitelisted. */
+function whitelisted(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null];
+	const parameterNames = ["self"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "whitelisted",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/** Accessor to check if the pool is a stablecoin pool. */
+function stablePool(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null];
+	const parameterNames = ["self"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "stable_pool",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+function registeredPool(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null];
+	const parameterNames = ["self"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "registered_pool",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Dry run to determine the quote quantity out for a given base quantity. Uses DEEP
+* token as fee.
+*/
+function getQuoteQuantityOut(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = ["self", "baseQuantity"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "get_quote_quantity_out",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Dry run to determine the base quantity out for a given quote quantity. Uses DEEP
+* token as fee.
+*/
+function getBaseQuantityOut(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = ["self", "quoteQuantity"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "get_base_quantity_out",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Dry run to determine the quote quantity out for a given base quantity. Uses
+* input token as fee.
+*/
+function getQuoteQuantityOutInputFee(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = ["self", "baseQuantity"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "get_quote_quantity_out_input_fee",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Dry run to determine the base quantity out for a given quote quantity. Uses
+* input token as fee.
+*/
+function getBaseQuantityOutInputFee(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = ["self", "quoteQuantity"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "get_base_quantity_out_input_fee",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Dry run to determine the quantity out for a given base or quote quantity. Only
+* one out of base or quote quantity should be non-zero. Returns the
+* (base_quantity_out, quote_quantity_out, deep_quantity_required) Uses DEEP token
+* as fee.
+*/
+function getQuantityOut(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		"u64",
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"self",
+		"baseQuantity",
+		"quoteQuantity"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "get_quantity_out",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Dry run to determine the quantity out for a given base or quote quantity. Only
+* one out of base or quote quantity should be non-zero. Returns the
+* (base_quantity_out, quote_quantity_out, deep_quantity_required) Uses input token
+* as fee.
+*/
+function getQuantityOutInputFee(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		"u64",
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"self",
+		"baseQuantity",
+		"quoteQuantity"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "get_quantity_out_input_fee",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Dry run to determine the base quantity needed to sell to receive a target quote
+* quantity. Returns (base_quantity_in, actual_quote_quantity_out,
+* deep_quantity_required) Returns (0, 0, 0) if insufficient liquidity or if result
+* would be below min_size.
+*/
+function getBaseQuantityIn(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		"u64",
+		"bool",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"self",
+		"targetQuoteQuantity",
+		"payWithDeep"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "get_base_quantity_in",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Dry run to determine the quote quantity needed to buy a target base quantity.
+* Returns (actual_base_quantity_out, quote_quantity_in, deep_quantity_required)
+* Returns (0, 0, 0) if insufficient liquidity or if result would be below
+* min_size.
+*/
+function getQuoteQuantityIn(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		"u64",
+		"bool",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"self",
+		"targetBaseQuantity",
+		"payWithDeep"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "get_quote_quantity_in",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/** Returns the mid price of the pool. */
+function midPrice(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null, "0x2::clock::Clock"];
+	const parameterNames = ["self"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "mid_price",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/** Returns the order_id for all open order for the balance_manager in the pool. */
+function accountOpenOrders(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null, null];
+	const parameterNames = ["self", "balanceManager"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "account_open_orders",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Returns the (price_vec, quantity_vec) for the level2 order book. The price_low
+* and price_high are inclusive, all orders within the range are returned. is_bid
+* is true for bids and false for asks.
+*/
+function getLevel2Range(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		"u64",
+		"u64",
+		"bool",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"self",
+		"priceLow",
+		"priceHigh",
+		"isBid"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "get_level2_range",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Returns the (price_vec, quantity_vec) for the level2 order book. Ticks are the
+* maximum number of ticks to return starting from best bid and best ask.
+* (bid_price, bid_quantity, ask_price, ask_quantity) are returned as 4 vectors.
+* The price vectors are sorted in descending order for bids and ascending order
+* for asks.
+*/
+function getLevel2TicksFromMid(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = ["self", "ticks"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "get_level2_ticks_from_mid",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/** Get all balances held in this pool. */
+function vaultBalances(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null];
+	const parameterNames = ["self"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "vault_balances",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/** Get the ID of the pool given the asset types. */
+function getPoolIdByAsset(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null];
+	const parameterNames = ["registry"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "get_pool_id_by_asset",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/** Get the Order struct */
+function getOrder(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null, "u128"];
+	const parameterNames = ["self", "orderId"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "get_order",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/** Get multiple orders given a vector of order_ids. */
+function getOrders(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null, "vector<u128>"];
+	const parameterNames = ["self", "orderIds"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "get_orders",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/** Return a copy of all orders that are in the book for this account. */
+function getAccountOrderDetails(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null, null];
+	const parameterNames = ["self", "balanceManager"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "get_account_order_details",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/** Return the DEEP price for the pool. */
+function getOrderDeepPrice(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null];
+	const parameterNames = ["self"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "get_order_deep_price",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Returns the deep required for an order if it's taker or maker given quantity and
+* price Does not account for discounted taker fees Returns (deep_required_taker,
+* deep_required_maker)
+*/
+function getOrderDeepRequired(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		"u64",
+		"u64"
+	];
+	const parameterNames = [
+		"self",
+		"baseQuantity",
+		"price"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "get_order_deep_required",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Returns the locked balance for the balance_manager in the pool Returns
+* (base_quantity, quote_quantity, deep_quantity)
+*/
+function lockedBalance(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null, null];
+	const parameterNames = ["self", "balanceManager"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "locked_balance",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Check if a limit order can be placed based on balance manager balances. Returns
+* true if the balance manager has sufficient balance (accounting for fees) to
+* place the order, false otherwise. Assumes the limit order is a taker order as a
+* worst case scenario.
+*/
+function canPlaceLimitOrder(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		"u64",
+		"u64",
+		"bool",
+		"bool",
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"self",
+		"balanceManager",
+		"price",
+		"quantity",
+		"isBid",
+		"payWithDeep",
+		"expireTimestamp"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "can_place_limit_order",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Check if a market order can be placed based on balance manager balances. Returns
+* true if the balance manager has sufficient balance (accounting for fees) to
+* place the order, false otherwise. Does not account for discounted taker fees
+*/
+function canPlaceMarketOrder(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		null,
+		"u64",
+		"bool",
+		"bool",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"self",
+		"balanceManager",
+		"quantity",
+		"isBid",
+		"payWithDeep"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "can_place_market_order",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Check if a market order can be placed based on pool book params. Returns true if
+* the order parameters are valid, false otherwise.
+*/
+function checkMarketOrderParams(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null, "u64"];
+	const parameterNames = ["self", "quantity"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "check_market_order_params",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Check if a limit order can be placed based on pool book params. Returns true if
+* the order parameters are valid, false otherwise.
+*/
+function checkLimitOrderParams(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [
+		null,
+		"u64",
+		"u64",
+		"u64",
+		"0x2::clock::Clock"
+	];
+	const parameterNames = [
+		"self",
+		"price",
+		"quantity",
+		"expireTimestamp"
+	];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "check_limit_order_params",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/**
+* Returns the trade params for the pool. Returns (taker_fee, maker_fee,
+* stake_required)
+*/
+function poolTradeParams(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null];
+	const parameterNames = ["self"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "pool_trade_params",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/** Returns the currently leading trade params for the next epoch for the pool */
+function poolTradeParamsNext(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null];
+	const parameterNames = ["self"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "pool_trade_params_next",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/** Returns the tick size, lot size, and min size for the pool. */
+function poolBookParams(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null];
+	const parameterNames = ["self"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "pool_book_params",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+function accountExists(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null, null];
+	const parameterNames = ["self", "balanceManager"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "account_exists",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+function account(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null, null];
+	const parameterNames = ["self", "balanceManager"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "account",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+/** Returns the quorum needed to pass proposal in the current epoch */
+function quorum(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null];
+	const parameterNames = ["self"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "quorum",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+function id(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null];
+	const parameterNames = ["self"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "id",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+function getPoolReferralBalances(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null, null];
+	const parameterNames = ["self", "referral"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "get_pool_referral_balances",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+function poolReferralMultiplier(options) {
+	const packageAddress = options.package ?? "@deepbook/core";
+	const argumentsTypes = [null, null];
+	const parameterNames = ["self", "referral"];
+	return (tx) => tx.moveCall({
+		package: packageAddress,
+		module: "pool",
+		function: "pool_referral_multiplier",
+		arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		typeArguments: options.typeArguments
+	});
+}
+
+//#endregion
+export { account, accountExists, accountOpenOrders, addDeepPricePoint, adjustMinLotSizeAdmin, adjustTickSizeAdmin, borrowFlashloanBase, borrowFlashloanQuote, burnDeep, canPlaceLimitOrder, canPlaceMarketOrder, cancelAllOrders, cancelLiveOrder, cancelLiveOrders, cancelOrder, cancelOrders, checkLimitOrderParams, checkMarketOrderParams, claimPoolReferralRewards, claimRebates, createPermissionlessPool, createPoolAdmin, enableEwmaState, getAccountOrderDetails, getBaseQuantityIn, getBaseQuantityOut, getBaseQuantityOutInputFee, getLevel2Range, getLevel2TicksFromMid, getOrder, getOrderDeepPrice, getOrderDeepRequired, getOrders, getPoolIdByAsset, getPoolReferralBalances, getQuantityOut, getQuantityOutInputFee, getQuoteQuantityIn, getQuoteQuantityOut, getQuoteQuantityOutInputFee, id, lockedBalance, midPrice, mintReferral, modifyOrder, placeLimitOrder, placeMarketOrder, poolBookParams, poolReferralMultiplier, poolTradeParams, poolTradeParamsNext, quorum, registeredPool, returnFlashloanBase, returnFlashloanQuote, setEwmaParams, stablePool, stake, submitProposal, swapExactBaseForQuote, swapExactBaseForQuoteWithManager, swapExactQuantity, swapExactQuantityWithManager, swapExactQuoteForBase, swapExactQuoteForBaseWithManager, unregisterPoolAdmin, unstake, updateAllowedVersions, updatePoolAllowedVersions, updatePoolReferralMultiplier, vaultBalances, vote, whitelisted, withdrawSettledAmounts, withdrawSettledAmountsPermissionless };
+//# sourceMappingURL=pool.mjs.map