@haneullabs/deepbook-v3 0.1.0

package/dist/esm/contracts/deepbook/pool.js

@@ -0,0 +1,1206 @@
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from "@haneullabs/haneul/bcs";
+import * as object from "./deps/sui/object.js";
+import * as versioned from "./deps/sui/versioned.js";
+import * as vec_set from "./deps/sui/vec_set.js";
+import * as book from "./book.js";
+import * as state from "./state.js";
+import * as vault from "./vault.js";
+import * as deep_price from "./deep_price.js";
+const $moduleName = "@deepbook/core::pool";
+const Pool = new MoveStruct({
+  name: `${$moduleName}::Pool`,
+  fields: {
+    id: object.UID,
+    inner: versioned.Versioned
+  }
+});
+const PoolInner = new MoveStruct({
+  name: `${$moduleName}::PoolInner`,
+  fields: {
+    allowed_versions: vec_set.VecSet(bcs.u64()),
+    pool_id: bcs.Address,
+    book: book.Book,
+    state: state.State,
+    vault: vault.Vault,
+    deep_price: deep_price.DeepPrice,
+    registered_pool: bcs.bool()
+  }
+});
+const PoolCreated = new MoveStruct({
+  name: `${$moduleName}::PoolCreated`,
+  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`,
+  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`,
+  fields: {
+    pool_id: bcs.Address,
+    deep_burned: bcs.u64()
+  }
+});
+const AppKey = new MoveStruct({
+  name: `${$moduleName}::AppKey`,
+  fields: {
+    dummy_field: bcs.bool()
+  }
+});
+const MarginTradingKey = new MoveStruct({
+  name: `${$moduleName}::MarginTradingKey`,
+  fields: {
+    dummy_field: bcs.bool()
+  }
+});
+function createPermissionlessPool(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::registry::Registry`,
+    "u64",
+    "u64",
+    "u64",
+    `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${packageAddress}::deep::DEEP>`
+  ];
+  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
+  });
+}
+function placeLimitOrder(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `${packageAddress}::balance_manager::BalanceManager`,
+    `${packageAddress}::balance_manager::TradeProof`,
+    "u64",
+    "u8",
+    "u8",
+    "u64",
+    "u64",
+    "bool",
+    "bool",
+    "u64",
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = [
+    "self",
+    "balanceManager",
+    "tradeProof",
+    "clientOrderId",
+    "orderType",
+    "selfMatchingOption",
+    "price",
+    "quantity",
+    "isBid",
+    "payWithDeep",
+    "expireTimestamp",
+    "clock"
+  ];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "place_limit_order",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function placeMarketOrder(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `${packageAddress}::balance_manager::BalanceManager`,
+    `${packageAddress}::balance_manager::TradeProof`,
+    "u64",
+    "u8",
+    "u64",
+    "bool",
+    "bool",
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = [
+    "self",
+    "balanceManager",
+    "tradeProof",
+    "clientOrderId",
+    "selfMatchingOption",
+    "quantity",
+    "isBid",
+    "payWithDeep",
+    "clock"
+  ];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "place_market_order",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function swapExactBaseForQuote(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${options.typeArguments[0]}>`,
+    `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${packageAddress}::deep::DEEP>`,
+    "u64",
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = ["self", "baseIn", "deepIn", "minQuoteOut", "clock"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "swap_exact_base_for_quote",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function swapExactQuoteForBase(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${options.typeArguments[1]}>`,
+    `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${packageAddress}::deep::DEEP>`,
+    "u64",
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = ["self", "quoteIn", "deepIn", "minBaseOut", "clock"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "swap_exact_quote_for_base",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function swapExactQuantity(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${options.typeArguments[0]}>`,
+    `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${options.typeArguments[1]}>`,
+    `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${packageAddress}::deep::DEEP>`,
+    "u64",
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = ["self", "baseIn", "quoteIn", "deepIn", "minOut", "clock"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "swap_exact_quantity",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function modifyOrder(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `${packageAddress}::balance_manager::BalanceManager`,
+    `${packageAddress}::balance_manager::TradeProof`,
+    "u128",
+    "u64",
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = [
+    "self",
+    "balanceManager",
+    "tradeProof",
+    "orderId",
+    "newQuantity",
+    "clock"
+  ];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "modify_order",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function cancelOrder(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `${packageAddress}::balance_manager::BalanceManager`,
+    `${packageAddress}::balance_manager::TradeProof`,
+    "u128",
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = ["self", "balanceManager", "tradeProof", "orderId", "clock"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "cancel_order",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function cancelOrders(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `${packageAddress}::balance_manager::BalanceManager`,
+    `${packageAddress}::balance_manager::TradeProof`,
+    "vector<u128>",
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = ["self", "balanceManager", "tradeProof", "orderIds", "clock"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "cancel_orders",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function cancelAllOrders(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `${packageAddress}::balance_manager::BalanceManager`,
+    `${packageAddress}::balance_manager::TradeProof`,
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = ["self", "balanceManager", "tradeProof", "clock"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "cancel_all_orders",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function withdrawSettledAmounts(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `${packageAddress}::balance_manager::BalanceManager`,
+    `${packageAddress}::balance_manager::TradeProof`
+  ];
+  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
+  });
+}
+function stake(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `${packageAddress}::balance_manager::BalanceManager`,
+    `${packageAddress}::balance_manager::TradeProof`,
+    "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
+  });
+}
+function unstake(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `${packageAddress}::balance_manager::BalanceManager`,
+    `${packageAddress}::balance_manager::TradeProof`
+  ];
+  const parameterNames = ["self", "balanceManager", "tradeProof"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "unstake",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function submitProposal(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `${packageAddress}::balance_manager::BalanceManager`,
+    `${packageAddress}::balance_manager::TradeProof`,
+    "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
+  });
+}
+function vote(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `${packageAddress}::balance_manager::BalanceManager`,
+    `${packageAddress}::balance_manager::TradeProof`,
+    "0x0000000000000000000000000000000000000000000000000000000000000002::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
+  });
+}
+function claimRebates(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `${packageAddress}::balance_manager::BalanceManager`,
+    `${packageAddress}::balance_manager::TradeProof`
+  ];
+  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
+  });
+}
+function borrowFlashloanBase(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    "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
+  });
+}
+function borrowFlashloanQuote(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    "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
+  });
+}
+function returnFlashloanBase(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${options.typeArguments[0]}>`,
+    `${packageAddress}::vault::FlashLoan`
+  ];
+  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
+  });
+}
+function returnFlashloanQuote(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${options.typeArguments[1]}>`,
+    `${packageAddress}::vault::FlashLoan`
+  ];
+  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
+  });
+}
+function addDeepPricePoint(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `${packageAddress}::pool::Pool<${options.typeArguments[2]}, ${options.typeArguments[3]}>`,
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = ["targetPool", "referencePool", "clock"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "add_deep_price_point",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function burnDeep(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `${packageAddress}::deep::ProtectedTreasury`
+  ];
+  const parameterNames = ["self", "treasuryCap"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "burn_deep",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function createPoolAdmin(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::registry::Registry`,
+    "u64",
+    "u64",
+    "u64",
+    "bool",
+    "bool",
+    `${packageAddress}::registry::DeepbookAdminCap`
+  ];
+  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
+  });
+}
+function unregisterPoolAdmin(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `${packageAddress}::registry::Registry`,
+    `${packageAddress}::registry::DeepbookAdminCap`
+  ];
+  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
+  });
+}
+function updateAllowedVersions(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `${packageAddress}::registry::Registry`,
+    `${packageAddress}::registry::DeepbookAdminCap`
+  ];
+  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
+  });
+}
+function updatePoolAllowedVersions(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `${packageAddress}::registry::Registry`
+  ];
+  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
+  });
+}
+function adjustTickSizeAdmin(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    "u64",
+    `${packageAddress}::registry::DeepbookAdminCap`,
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = ["self", "newTickSize", "Cap", "clock"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "adjust_tick_size_admin",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function adjustMinLotSizeAdmin(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    "u64",
+    "u64",
+    `${packageAddress}::registry::DeepbookAdminCap`,
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = ["self", "newLotSize", "newMinSize", "Cap", "clock"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "adjust_min_lot_size_admin",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function authorizeApp(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[1]}, ${options.typeArguments[2]}>`,
+    `${packageAddress}::registry::DeepbookAdminCap`
+  ];
+  const parameterNames = ["self", "Cap"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "authorize_app",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function deauthorizeApp(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[1]}, ${options.typeArguments[2]}>`,
+    `${packageAddress}::registry::DeepbookAdminCap`
+  ];
+  const parameterNames = ["self", "Cap"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "deauthorize_app",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function enableEwmaState(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `${packageAddress}::registry::DeepbookAdminCap`,
+    "bool",
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = ["self", "Cap", "enable", "clock"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "enable_ewma_state",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function setEwmaParams(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `${packageAddress}::registry::DeepbookAdminCap`,
+    "u64",
+    "u64",
+    "u64",
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = ["self", "Cap", "alpha", "zScoreThreshold", "additionalTakerFee", "clock"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "set_ewma_params",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function updateMarginStatus(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[1]}, ${options.typeArguments[2]}>`,
+    `${options.typeArguments[0]}`,
+    "bool"
+  ];
+  const parameterNames = ["self", "_", "enable"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "update_margin_status",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function whitelisted(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`
+  ];
+  const parameterNames = ["self"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "whitelisted",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function stablePool(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`
+  ];
+  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 = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`
+  ];
+  const parameterNames = ["self"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "registered_pool",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function getQuoteQuantityOut(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    "u64",
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = ["self", "baseQuantity", "clock"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "get_quote_quantity_out",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function getBaseQuantityOut(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    "u64",
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = ["self", "quoteQuantity", "clock"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "get_base_quantity_out",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function getQuoteQuantityOutInputFee(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    "u64",
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = ["self", "baseQuantity", "clock"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "get_quote_quantity_out_input_fee",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function getBaseQuantityOutInputFee(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    "u64",
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = ["self", "quoteQuantity", "clock"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "get_base_quantity_out_input_fee",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function getQuantityOut(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    "u64",
+    "u64",
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = ["self", "baseQuantity", "quoteQuantity", "clock"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "get_quantity_out",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function getQuantityOutInputFee(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    "u64",
+    "u64",
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = ["self", "baseQuantity", "quoteQuantity", "clock"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "get_quantity_out_input_fee",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function midPrice(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = ["self", "clock"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "mid_price",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function accountOpenOrders(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `${packageAddress}::balance_manager::BalanceManager`
+  ];
+  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
+  });
+}
+function getLevel2Range(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    "u64",
+    "u64",
+    "bool",
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = ["self", "priceLow", "priceHigh", "isBid", "clock"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "get_level2_range",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function getLevel2TicksFromMid(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    "u64",
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = ["self", "ticks", "clock"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "get_level2_ticks_from_mid",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function vaultBalances(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`
+  ];
+  const parameterNames = ["self"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "vault_balances",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function getPoolIdByAsset(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [`${packageAddress}::registry::Registry`];
+  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
+  });
+}
+function getOrder(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    "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
+  });
+}
+function getOrders(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    "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
+  });
+}
+function getAccountOrderDetails(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `${packageAddress}::balance_manager::BalanceManager`
+  ];
+  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
+  });
+}
+function getOrderDeepPrice(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`
+  ];
+  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
+  });
+}
+function getOrderDeepRequired(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    "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
+  });
+}
+function lockedBalance(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `${packageAddress}::balance_manager::BalanceManager`
+  ];
+  const parameterNames = ["self", "balanceManager"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "locked_balance",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function poolTradeParams(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`
+  ];
+  const parameterNames = ["self"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "pool_trade_params",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function poolTradeParamsNext(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`
+  ];
+  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
+  });
+}
+function poolBookParams(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`
+  ];
+  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 account(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `${packageAddress}::balance_manager::BalanceManager`
+  ];
+  const parameterNames = ["self", "balanceManager"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "account",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function quorum(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`
+  ];
+  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 = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`
+  ];
+  const parameterNames = ["self"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "id",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function marginTradingEnabled(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[0]}, ${options.typeArguments[1]}>`
+  ];
+  const parameterNames = ["self"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "margin_trading_enabled",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function isAppAuthorized(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[1]}, ${options.typeArguments[2]}>`
+  ];
+  const parameterNames = ["self"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "is_app_authorized",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function assertAppIsAuthorized(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::pool::Pool<${options.typeArguments[1]}, ${options.typeArguments[2]}>`
+  ];
+  const parameterNames = ["self"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "pool",
+    function: "assert_app_is_authorized",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+export {
+  AppKey,
+  BookParamsUpdated,
+  DeepBurned,
+  MarginTradingKey,
+  Pool,
+  PoolCreated,
+  PoolInner,
+  account,
+  accountOpenOrders,
+  addDeepPricePoint,
+  adjustMinLotSizeAdmin,
+  adjustTickSizeAdmin,
+  assertAppIsAuthorized,
+  authorizeApp,
+  borrowFlashloanBase,
+  borrowFlashloanQuote,
+  burnDeep,
+  cancelAllOrders,
+  cancelOrder,
+  cancelOrders,
+  claimRebates,
+  createPermissionlessPool,
+  createPoolAdmin,
+  deauthorizeApp,
+  enableEwmaState,
+  getAccountOrderDetails,
+  getBaseQuantityOut,
+  getBaseQuantityOutInputFee,
+  getLevel2Range,
+  getLevel2TicksFromMid,
+  getOrder,
+  getOrderDeepPrice,
+  getOrderDeepRequired,
+  getOrders,
+  getPoolIdByAsset,
+  getQuantityOut,
+  getQuantityOutInputFee,
+  getQuoteQuantityOut,
+  getQuoteQuantityOutInputFee,
+  id,
+  isAppAuthorized,
+  lockedBalance,
+  marginTradingEnabled,
+  midPrice,
+  modifyOrder,
+  placeLimitOrder,
+  placeMarketOrder,
+  poolBookParams,
+  poolTradeParams,
+  poolTradeParamsNext,
+  quorum,
+  registeredPool,
+  returnFlashloanBase,
+  returnFlashloanQuote,
+  setEwmaParams,
+  stablePool,
+  stake,
+  submitProposal,
+  swapExactBaseForQuote,
+  swapExactQuantity,
+  swapExactQuoteForBase,
+  unregisterPoolAdmin,
+  unstake,
+  updateAllowedVersions,
+  updateMarginStatus,
+  updatePoolAllowedVersions,
+  vaultBalances,
+  vote,
+  whitelisted,
+  withdrawSettledAmounts
+};
+//# sourceMappingURL=pool.js.map