@haneullabs/deepbook-v3 0.1.0

package/src/contracts/deepbook/constants.ts

@@ -0,0 +1,458 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+import type { Transaction } from '@haneullabs/haneul/transactions';
+export interface CurrentVersionOptions {
+	package?: string;
+	arguments?: [];
+}
+export function currentVersion(options: CurrentVersionOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'current_version',
+		});
+}
+export interface PoolCreationFeeOptions {
+	package?: string;
+	arguments?: [];
+}
+export function poolCreationFee(options: PoolCreationFeeOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'pool_creation_fee',
+		});
+}
+export interface FloatScalingOptions {
+	package?: string;
+	arguments?: [];
+}
+export function floatScaling(options: FloatScalingOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'float_scaling',
+		});
+}
+export interface FloatScalingU128Options {
+	package?: string;
+	arguments?: [];
+}
+export function floatScalingU128(options: FloatScalingU128Options = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'float_scaling_u128',
+		});
+}
+export interface MaxU64Options {
+	package?: string;
+	arguments?: [];
+}
+export function maxU64(options: MaxU64Options = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'max_u64',
+		});
+}
+export interface MaxU128Options {
+	package?: string;
+	arguments?: [];
+}
+export function maxU128(options: MaxU128Options = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'max_u128',
+		});
+}
+export interface NoRestrictionOptions {
+	package?: string;
+	arguments?: [];
+}
+export function noRestriction(options: NoRestrictionOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'no_restriction',
+		});
+}
+export interface ImmediateOrCancelOptions {
+	package?: string;
+	arguments?: [];
+}
+export function immediateOrCancel(options: ImmediateOrCancelOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'immediate_or_cancel',
+		});
+}
+export interface FillOrKillOptions {
+	package?: string;
+	arguments?: [];
+}
+export function fillOrKill(options: FillOrKillOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'fill_or_kill',
+		});
+}
+export interface PostOnlyOptions {
+	package?: string;
+	arguments?: [];
+}
+export function postOnly(options: PostOnlyOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'post_only',
+		});
+}
+export interface MaxRestrictionOptions {
+	package?: string;
+	arguments?: [];
+}
+export function maxRestriction(options: MaxRestrictionOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'max_restriction',
+		});
+}
+export interface LiveOptions {
+	package?: string;
+	arguments?: [];
+}
+export function live(options: LiveOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'live',
+		});
+}
+export interface PartiallyFilledOptions {
+	package?: string;
+	arguments?: [];
+}
+export function partiallyFilled(options: PartiallyFilledOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'partially_filled',
+		});
+}
+export interface FilledOptions {
+	package?: string;
+	arguments?: [];
+}
+export function filled(options: FilledOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'filled',
+		});
+}
+export interface CanceledOptions {
+	package?: string;
+	arguments?: [];
+}
+export function canceled(options: CanceledOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'canceled',
+		});
+}
+export interface ExpiredOptions {
+	package?: string;
+	arguments?: [];
+}
+export function expired(options: ExpiredOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'expired',
+		});
+}
+export interface SelfMatchingAllowedOptions {
+	package?: string;
+	arguments?: [];
+}
+export function selfMatchingAllowed(options: SelfMatchingAllowedOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'self_matching_allowed',
+		});
+}
+export interface CancelTakerOptions {
+	package?: string;
+	arguments?: [];
+}
+export function cancelTaker(options: CancelTakerOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'cancel_taker',
+		});
+}
+export interface CancelMakerOptions {
+	package?: string;
+	arguments?: [];
+}
+export function cancelMaker(options: CancelMakerOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'cancel_maker',
+		});
+}
+export interface MinPriceOptions {
+	package?: string;
+	arguments?: [];
+}
+export function minPrice(options: MinPriceOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'min_price',
+		});
+}
+export interface MaxPriceOptions {
+	package?: string;
+	arguments?: [];
+}
+export function maxPrice(options: MaxPriceOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'max_price',
+		});
+}
+export interface PhaseOutEpochsOptions {
+	package?: string;
+	arguments?: [];
+}
+export function phaseOutEpochs(options: PhaseOutEpochsOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'phase_out_epochs',
+		});
+}
+export interface DefaultStakeRequiredOptions {
+	package?: string;
+	arguments?: [];
+}
+export function defaultStakeRequired(options: DefaultStakeRequiredOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'default_stake_required',
+		});
+}
+export interface HalfOptions {
+	package?: string;
+	arguments?: [];
+}
+export function half(options: HalfOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'half',
+		});
+}
+export interface FeeIsDeepOptions {
+	package?: string;
+	arguments?: [];
+}
+export function feeIsDeep(options: FeeIsDeepOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'fee_is_deep',
+		});
+}
+export interface DeepUnitOptions {
+	package?: string;
+	arguments?: [];
+}
+export function deepUnit(options: DeepUnitOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'deep_unit',
+		});
+}
+export interface MaxFillsOptions {
+	package?: string;
+	arguments?: [];
+}
+export function maxFills(options: MaxFillsOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'max_fills',
+		});
+}
+export interface MaxOpenOrdersOptions {
+	package?: string;
+	arguments?: [];
+}
+export function maxOpenOrders(options: MaxOpenOrdersOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'max_open_orders',
+		});
+}
+export interface MaxSliceSizeOptions {
+	package?: string;
+	arguments?: [];
+}
+export function maxSliceSize(options: MaxSliceSizeOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'max_slice_size',
+		});
+}
+export interface MaxFanOutOptions {
+	package?: string;
+	arguments?: [];
+}
+export function maxFanOut(options: MaxFanOutOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'max_fan_out',
+		});
+}
+export interface FeePenaltyMultiplierOptions {
+	package?: string;
+	arguments?: [];
+}
+export function feePenaltyMultiplier(options: FeePenaltyMultiplierOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'fee_penalty_multiplier',
+		});
+}
+export interface DefaultEwmaAlphaOptions {
+	package?: string;
+	arguments?: [];
+}
+export function defaultEwmaAlpha(options: DefaultEwmaAlphaOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'default_ewma_alpha',
+		});
+}
+export interface DefaultZScoreThresholdOptions {
+	package?: string;
+	arguments?: [];
+}
+export function defaultZScoreThreshold(options: DefaultZScoreThresholdOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'default_z_score_threshold',
+		});
+}
+export interface DefaultAdditionalTakerFeeOptions {
+	package?: string;
+	arguments?: [];
+}
+export function defaultAdditionalTakerFee(options: DefaultAdditionalTakerFeeOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'default_additional_taker_fee',
+		});
+}
+export interface EwmaDfKeyOptions {
+	package?: string;
+	arguments?: [];
+}
+export function ewmaDfKey(options: EwmaDfKeyOptions = {}) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'constants',
+			function: 'ewma_df_key',
+		});
+}

package/src/contracts/deepbook/deep_price.ts

@@ -0,0 +1,84 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * DEEP price module. This module maintains the conversion rate between DEEP and
+ * the base and quote assets.
+ */
+
+import { MoveStruct, normalizeMoveArguments } from '../utils/index.js';
+import type { RawTransactionArgument } from '../utils/index.js';
+import { bcs } from '@haneullabs/haneul/bcs';
+import type { Transaction } from '@haneullabs/haneul/transactions';
+const $moduleName = '@deepbook/core::deep_price';
+export const Price = new MoveStruct({
+	name: `${$moduleName}::Price`,
+	fields: {
+		conversion_rate: bcs.u64(),
+		timestamp: bcs.u64(),
+	},
+});
+export const PriceAdded = new MoveStruct({
+	name: `${$moduleName}::PriceAdded`,
+	fields: {
+		conversion_rate: bcs.u64(),
+		timestamp: bcs.u64(),
+		is_base_conversion: bcs.bool(),
+		reference_pool: bcs.Address,
+		target_pool: bcs.Address,
+	},
+});
+export const DeepPrice = new MoveStruct({
+	name: `${$moduleName}::DeepPrice`,
+	fields: {
+		base_prices: bcs.vector(Price),
+		cumulative_base: bcs.u64(),
+		quote_prices: bcs.vector(Price),
+		cumulative_quote: bcs.u64(),
+	},
+});
+export const OrderDeepPrice = new MoveStruct({
+	name: `${$moduleName}::OrderDeepPrice`,
+	fields: {
+		asset_is_base: bcs.bool(),
+		deep_per_asset: bcs.u64(),
+	},
+});
+export interface AssetIsBaseArguments {
+	self: RawTransactionArgument<string>;
+}
+export interface AssetIsBaseOptions {
+	package?: string;
+	arguments: AssetIsBaseArguments | [self: RawTransactionArgument<string>];
+}
+export function assetIsBase(options: AssetIsBaseOptions) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	const argumentsTypes = [`${packageAddress}::deep_price::OrderDeepPrice`] satisfies string[];
+	const parameterNames = ['self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'deep_price',
+			function: 'asset_is_base',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}
+export interface DeepPerAssetArguments {
+	self: RawTransactionArgument<string>;
+}
+export interface DeepPerAssetOptions {
+	package?: string;
+	arguments: DeepPerAssetArguments | [self: RawTransactionArgument<string>];
+}
+export function deepPerAsset(options: DeepPerAssetOptions) {
+	const packageAddress = options.package ?? '@deepbook/core';
+	const argumentsTypes = [`${packageAddress}::deep_price::OrderDeepPrice`] satisfies string[];
+	const parameterNames = ['self'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'deep_price',
+			function: 'deep_per_asset',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}

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

@@ -0,0 +1,23 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/** Functionality for converting Move types into values. Use with care! */
+
+import { MoveStruct } from '../../../utils/index.js';
+import { bcs } from '@haneullabs/haneul/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/deps/sui/bag.ts

@@ -0,0 +1,41 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * 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 '@haneullabs/haneul/bcs';
+import * as object from './object.js';
+const $moduleName = '0x2::bag';
+export const Bag = new MoveStruct({
+	name: `${$moduleName}::Bag`,
+	fields: {
+		/** the ID of this bag */
+		id: object.UID,
+		/** the number of key-value pairs in the bag */
+		size: bcs.u64(),
+	},
+});

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

@@ -0,0 +1,18 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * 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 '@haneullabs/haneul/bcs';
+const $moduleName = '0x2::balance';
+export const Balance = new MoveStruct({
+	name: `${$moduleName}::Balance`,
+	fields: {
+		value: bcs.u64(),
+	},
+});

package/src/contracts/deepbook/deps/sui/object.ts

@@ -0,0 +1,14 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/** Sui object identifiers */
+
+import { MoveStruct } from '../../../utils/index.js';
+import { bcs } from '@haneullabs/haneul/bcs';
+const $moduleName = '0x2::object';
+export const UID = new MoveStruct({
+	name: `${$moduleName}::UID`,
+	fields: {
+		id: bcs.Address,
+	},
+});

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

@@ -0,0 +1,36 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * 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 '@haneullabs/haneul/bcs';
+import * as object from './object.js';
+const $moduleName = '0x2::table';
+export const Table = new MoveStruct({
+	name: `${$moduleName}::Table`,
+	fields: {
+		/** the ID of this table */
+		id: object.UID,
+		/** the number of key-value pairs in the table */
+		size: bcs.u64(),
+	},
+});