@mysten/deepbook-v3 1.5.8 → 1.6.2

package/src/contracts/deepbook/registry.ts

@@ -4,7 +4,12 @@
 
 /** Registry holds all created pools. */
 
-import { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import {
+	MoveStruct,
+	MoveTuple,
+	normalizeMoveArguments,
+	type RawTransactionArgument,
+} from '../utils/index.js';
 import { bcs } from '@mysten/sui/bcs';
 import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
 import * as versioned from './deps/sui/versioned.js';
@@ -24,6 +29,12 @@ export const DeepbookAdminCap = new MoveStruct({
 		id: bcs.Address,
 	},
 });
+export const DeepbookCorePauseCap = new MoveStruct({
+	name: `${$moduleName}::DeepbookCorePauseCap`,
+	fields: {
+		id: bcs.Address,
+	},
+});
 export const Registry = new MoveStruct({
 	name: `${$moduleName}::Registry`,
 	fields: {
@@ -58,12 +69,22 @@ export const BalanceManagerKey = new MoveStruct({
 		dummy_field: bcs.bool(),
 	},
 });
+export const AllowedPauseCapsKey = new MoveTuple({
+	name: `${$moduleName}::AllowedPauseCapsKey`,
+	fields: [bcs.bool()],
+});
 export const AppKey = new MoveStruct({
 	name: `${$moduleName}::AppKey<phantom App>`,
 	fields: {
 		dummy_field: bcs.bool(),
 	},
 });
+export const AppKeyV2 = new MoveStruct({
+	name: `${$moduleName}::AppKeyV2<phantom App>`,
+	fields: {
+		dummy_field: bcs.bool(),
+	},
+});
 export interface AuthorizeAppArguments {
 	self: RawTransactionArgument<string>;
 	AdminCap: RawTransactionArgument<string>;
@@ -232,6 +253,97 @@ export function disableVersion(options: DisableVersionOptions) {
 			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
 		});
 }
+export interface MintPauseCapArguments {
+	self: RawTransactionArgument<string>;
+	Cap: RawTransactionArgument<string>;
+}
+export interface MintPauseCapOptions {
+	package?: string;
+	arguments:
+		| MintPauseCapArguments
+		| [self: RawTransactionArgument<string>, Cap: RawTransactionArgument<string>];
+}
+/**
+ * Mint a `DeepbookCorePauseCap`. The new cap's ID is recorded so it can later
+ * disable a version via `disable_version_pause_cap`. Only Admin can mint. This
+ * function does not have version restrictions.
+ */
+export function mintPauseCap(options: MintPauseCapOptions) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	const argumentsTypes = [null, null] satisfies (string | null)[];
+	const parameterNames = ['self', 'Cap'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'registry',
+			function: 'mint_pause_cap',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface RevokePauseCapArguments {
+	self: RawTransactionArgument<string>;
+	Cap: RawTransactionArgument<string>;
+	pauseCapId: RawTransactionArgument<string>;
+}
+export interface RevokePauseCapOptions {
+	package?: string;
+	arguments:
+		| RevokePauseCapArguments
+		| [
+				self: RawTransactionArgument<string>,
+				Cap: RawTransactionArgument<string>,
+				pauseCapId: RawTransactionArgument<string>,
+		  ];
+}
+/**
+ * Revoke a previously minted pause cap by ID. Only Admin can revoke. This function
+ * does not have version restrictions.
+ */
+export function revokePauseCap(options: RevokePauseCapOptions) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	const argumentsTypes = [null, null, '0x2::object::ID'] satisfies (string | null)[];
+	const parameterNames = ['self', 'Cap', 'pauseCapId'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'registry',
+			function: 'revoke_pause_cap',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface DisableVersionPauseCapArguments {
+	self: RawTransactionArgument<string>;
+	version: RawTransactionArgument<number | bigint>;
+	pauseCap: RawTransactionArgument<string>;
+}
+export interface DisableVersionPauseCapOptions {
+	package?: string;
+	arguments:
+		| DisableVersionPauseCapArguments
+		| [
+				self: RawTransactionArgument<string>,
+				version: RawTransactionArgument<number | bigint>,
+				pauseCap: RawTransactionArgument<string>,
+		  ];
+}
+/**
+ * Disable any allowed package version (including the current one) using a valid
+ * `DeepbookCorePauseCap`. The pause cap must be in `allowed_pause_caps`. This
+ * function is the emergency kill switch; admin can re-enable via `enable_version`.
+ * This function does not have version restrictions.
+ */
+export function disableVersionPauseCap(options: DisableVersionPauseCapOptions) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	const argumentsTypes = [null, 'u64', null] satisfies (string | null)[];
+	const parameterNames = ['self', 'version', 'pauseCap'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'registry',
+			function: 'disable_version_pause_cap',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
 export interface AddStablecoinArguments {
 	self: RawTransactionArgument<string>;
 	Cap: RawTransactionArgument<string>;
@@ -328,6 +440,29 @@ export function getBalanceManagerIds(options: GetBalanceManagerIdsOptions) {
 			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
 		});
 }
+export interface AllowedPauseCapsArguments {
+	self: RawTransactionArgument<string>;
+}
+export interface AllowedPauseCapsOptions {
+	package?: string;
+	arguments: AllowedPauseCapsArguments | [self: RawTransactionArgument<string>];
+}
+/**
+ * Get the set of pause cap IDs allowed to disable package versions. Returns an
+ * empty set if no pause caps have been minted yet.
+ */
+export function allowedPauseCaps(options: AllowedPauseCapsOptions) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'registry',
+			function: 'allowed_pause_caps',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
 export interface IsStablecoinArguments {
 	self: RawTransactionArgument<string>;
 	stableType: TransactionArgument;

package/src/contracts/deepbook_margin/deps/deepbook/balance_manager.ts

@@ -0,0 +1,49 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * The BalanceManager is a shared object that holds all of the balances for
+ * different assets. A combination of `BalanceManager` and `TradeProof` are passed
+ * into a pool to perform trades. A `TradeProof` can be generated in two ways: by
+ * the owner directly, or by any `TradeCap` owner. The owner can generate a
+ * `TradeProof` without the risk of equivocation. The `TradeCap` owner, due to it
+ * being an owned object, risks equivocation when generating a `TradeProof`.
+ * Generally, a high frequency trading engine will trade as the default owner.
+ */
+
+import { MoveStruct } from '../../../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import * as bag from '../sui/bag.js';
+import * as vec_set from '../sui/vec_set.js';
+const $moduleName = 'deepbook::balance_manager';
+export const BalanceManager = new MoveStruct({
+	name: `${$moduleName}::BalanceManager`,
+	fields: {
+		id: bcs.Address,
+		owner: bcs.Address,
+		balances: bag.Bag,
+		allow_listed: vec_set.VecSet(bcs.Address),
+	},
+});
+export const DepositCap = new MoveStruct({
+	name: `${$moduleName}::DepositCap`,
+	fields: {
+		id: bcs.Address,
+		balance_manager_id: bcs.Address,
+	},
+});
+export const WithdrawCap = new MoveStruct({
+	name: `${$moduleName}::WithdrawCap`,
+	fields: {
+		id: bcs.Address,
+		balance_manager_id: bcs.Address,
+	},
+});
+export const TradeCap = new MoveStruct({
+	name: `${$moduleName}::TradeCap`,
+	fields: {
+		id: bcs.Address,
+		balance_manager_id: bcs.Address,
+	},
+});

package/src/contracts/deepbook_margin/deps/std/type_name.ts

@@ -0,0 +1,24 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/** Functionality for converting Move types into values. Use with care! */
+
+import { MoveStruct } from '../../../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = 'std::type_name';
+export const TypeName = new MoveStruct({
+	name: `${$moduleName}::TypeName`,
+	fields: {
+		/**
+		 * String representation of the type. All types are represented using their source
+		 * syntax: "u8", "u64", "bool", "address", "vector", and so on for primitive types.
+		 * Struct types are represented as fully qualified type names; e.g.
+		 * `00000000000000000000000000000001::string::String` or
+		 * `0000000000000000000000000000000a::module_name1::type_name1<0000000000000000000000000000000a::module_name2::type_name2<u64>>`
+		 * Addresses are hex-encoded lowercase values of length ADDRESS_LENGTH (16, 20, or
+		 * 32 depending on the Move platform)
+		 */
+		name: bcs.string(),
+	},
+});

package/src/contracts/deepbook_margin/deps/sui/bag.ts

@@ -0,0 +1,41 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * A bag is a heterogeneous map-like collection. The collection is similar to
+ * `sui::table` in that its keys and values are not stored within the `Bag` value,
+ * but instead are stored using Sui's object system. The `Bag` struct acts only as
+ * a handle into the object system to retrieve those keys and values. Note that
+ * this means that `Bag` values with exactly the same key-value mapping will not be
+ * equal, with `==`, at runtime. For example
+ *
+ * ```
+ * let bag1 = bag::new();
+ * let bag2 = bag::new();
+ * bag::add(&mut bag1, 0, false);
+ * bag::add(&mut bag1, 1, true);
+ * bag::add(&mut bag2, 0, false);
+ * bag::add(&mut bag2, 1, true);
+ * // bag1 does not equal bag2, despite having the same entries
+ * assert!(&bag1 != &bag2);
+ * ```
+ *
+ * At it's core, `sui::bag` is a wrapper around `UID` that allows for access to
+ * `sui::dynamic_field` while preventing accidentally stranding field values. A
+ * `UID` can be deleted, even if it has dynamic fields associated with it, but a
+ * bag, on the other hand, must be empty to be destroyed.
+ */
+
+import { MoveStruct } from '../../../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = '0x2::bag';
+export const Bag = new MoveStruct({
+	name: `${$moduleName}::Bag`,
+	fields: {
+		/** the ID of this bag */
+		id: bcs.Address,
+		/** the number of key-value pairs in the bag */
+		size: bcs.u64(),
+	},
+});

package/src/contracts/deepbook_margin/deps/sui/balance.ts

@@ -0,0 +1,19 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * A storable handler for Balances in general. Is used in the `Coin` module to
+ * allow balance operations and can be used to implement custom coins with `Supply`
+ * and `Balance`s.
+ */
+
+import { MoveStruct } from '../../../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = '0x2::balance';
+export const Balance = new MoveStruct({
+	name: `${$moduleName}::Balance<phantom T>`,
+	fields: {
+		value: bcs.u64(),
+	},
+});

package/src/contracts/deepbook_margin/deps/sui/table.ts

@@ -0,0 +1,36 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * A table is a map-like collection. But unlike a traditional collection, it's keys
+ * and values are not stored within the `Table` value, but instead are stored using
+ * Sui's object system. The `Table` struct acts only as a handle into the object
+ * system to retrieve those keys and values. Note that this means that `Table`
+ * values with exactly the same key-value mapping will not be equal, with `==`, at
+ * runtime. For example
+ *
+ * ```
+ * let table1 = table::new<u64, bool>();
+ * let table2 = table::new<u64, bool>();
+ * table::add(&mut table1, 0, false);
+ * table::add(&mut table1, 1, true);
+ * table::add(&mut table2, 0, false);
+ * table::add(&mut table2, 1, true);
+ * // table1 does not equal table2, despite having the same entries
+ * assert!(&table1 != &table2);
+ * ```
+ */
+
+import { MoveStruct } from '../../../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = '0x2::table';
+export const Table = new MoveStruct({
+	name: `${$moduleName}::Table<phantom K, phantom V>`,
+	fields: {
+		/** the ID of this table */
+		id: bcs.Address,
+		/** the number of key-value pairs in the table */
+		size: bcs.u64(),
+	},
+});

package/src/contracts/deepbook_margin/deps/sui/vec_map.ts

@@ -0,0 +1,33 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type BcsType, bcs } from '@mysten/sui/bcs';
+import { MoveStruct } from '../../../utils/index.js';
+const $moduleName = '0x2::vec_map';
+/** An entry in the map */
+export function Entry<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [K, V]) {
+	return new MoveStruct({
+		name: `${$moduleName}::Entry<${typeParameters[0].name as K['name']}, ${typeParameters[1].name as V['name']}>`,
+		fields: {
+			key: typeParameters[0],
+			value: typeParameters[1],
+		},
+	});
+}
+/**
+ * A map data structure backed by a vector. The map is guaranteed not to contain
+ * duplicate keys, but entries are _not_ sorted by key--entries are included in
+ * insertion order. All operations are O(N) in the size of the map--the intention
+ * of this data structure is only to provide the convenience of programming against
+ * a map API. Large maps should use handwritten parent/child relationships instead.
+ * Maps that need sorted iteration rather than insertion order iteration should
+ * also be handwritten.
+ */
+export function VecMap<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [K, V]) {
+	return new MoveStruct({
+		name: `${$moduleName}::VecMap<${typeParameters[0].name as K['name']}, ${typeParameters[1].name as V['name']}>`,
+		fields: {
+			contents: bcs.vector(Entry(typeParameters[0], typeParameters[1])),
+		},
+	});
+}

package/src/contracts/deepbook_margin/deps/sui/vec_set.ts

@@ -0,0 +1,22 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type BcsType, bcs } from '@mysten/sui/bcs';
+import { MoveStruct } from '../../../utils/index.js';
+const $moduleName = '0x2::vec_set';
+/**
+ * A set data structure backed by a vector. The set is guaranteed not to contain
+ * duplicate keys. All operations are O(N) in the size of the set
+ *
+ * - the intention of this data structure is only to provide the convenience of
+ *   programming against a set API. Sets that need sorted iteration rather than
+ *   insertion order iteration should be handwritten.
+ */
+export function VecSet<K extends BcsType<any>>(...typeParameters: [K]) {
+	return new MoveStruct({
+		name: `${$moduleName}::VecSet<${typeParameters[0].name as K['name']}>`,
+		fields: {
+			contents: bcs.vector(typeParameters[0]),
+		},
+	});
+}

package/src/contracts/deepbook_margin/deps/sui/versioned.ts

@@ -0,0 +1,13 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct } from '../../../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = '0x2::versioned';
+export const Versioned = new MoveStruct({
+	name: `${$moduleName}::Versioned`,
+	fields: {
+		id: bcs.Address,
+		version: bcs.u64(),
+	},
+});