@mysten/deepbook-v3 2.0.1 → 2.1.4

package/src/contracts/account/account_events.ts

@@ -0,0 +1,64 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * Defines canonical-account lifecycle, app-authorization, and per-coin custody
+ * events. `account_registry` emits creation and authorization transitions;
+ * `account` emits balance transitions.
+ */
+
+import { MoveStruct } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import { U64 } from '../../bcs/integers.js';
+const $moduleName = '@local-pkg/account::account_events';
+export const AccountCreated = new MoveStruct({
+	name: `${$moduleName}::AccountCreated`,
+	fields: {
+		account_id: bcs.Address,
+		wrapper_id: bcs.Address,
+		owner: bcs.Address,
+		self_owned: bcs.bool(),
+		referrer_account_id: bcs.option(bcs.Address),
+	},
+});
+export const AppAuthorized = new MoveStruct({
+	name: `${$moduleName}::AppAuthorized`,
+	fields: {
+		/** Fully-qualified `App` witness type name. */
+		app: bcs.string(),
+	},
+});
+export const AppDeauthorized = new MoveStruct({
+	name: `${$moduleName}::AppDeauthorized`,
+	fields: {
+		app: bcs.string(),
+	},
+});
+export const Deposited = new MoveStruct({
+	name: `${$moduleName}::Deposited`,
+	fields: {
+		account_id: bcs.Address,
+		coin_type: bcs.string(),
+		amount: U64,
+		new_balance: U64,
+	},
+});
+export const Withdrawn = new MoveStruct({
+	name: `${$moduleName}::Withdrawn`,
+	fields: {
+		account_id: bcs.Address,
+		coin_type: bcs.string(),
+		amount: U64,
+		new_balance: U64,
+	},
+});
+export const FundsSettled = new MoveStruct({
+	name: `${$moduleName}::FundsSettled`,
+	fields: {
+		account_id: bcs.Address,
+		coin_type: bcs.string(),
+		amount: U64,
+		new_balance: U64,
+	},
+});

package/src/contracts/account/account_registry.ts

@@ -0,0 +1,468 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * Owns the derivation root for canonical accounts and the global whitelist of
+ * application witness types. App authorization is package-wide rather than
+ * per-account: an authorized app can request full mutable authority for any
+ * account wrapper supplied to its flow. `account::account` owns wrapper
+ * construction, custody, accumulator settlement, and app-data invariants.
+ */
+
+import {
+	MoveStruct,
+	MoveTuple,
+	normalizeMoveArguments,
+	type RawTransactionArgument,
+	type ConfigValue,
+} from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+const $moduleName = '@local-pkg/account::account_registry';
+export const AccountAdminCap = new MoveStruct({
+	name: `${$moduleName}::AccountAdminCap`,
+	fields: {
+		id: bcs.Address,
+	},
+});
+export const AccountRegistry = new MoveStruct({
+	name: `${$moduleName}::AccountRegistry`,
+	fields: {
+		id: bcs.Address,
+	},
+});
+export const AccountKey = new MoveTuple({
+	name: `${$moduleName}::AccountKey`,
+	fields: [bcs.Address],
+});
+export const AccountWrapperKey = new MoveTuple({
+	name: `${$moduleName}::AccountWrapperKey`,
+	fields: [bcs.Address],
+});
+export const AppKey = new MoveTuple({
+	name: `${$moduleName}::AppKey<phantom App>`,
+	fields: [bcs.bool()],
+});
+export interface DerivedAddressArguments {
+	registry?: RawTransactionArgument<string>;
+	owner: RawTransactionArgument<string>;
+}
+export interface DerivedAddressOptions {
+	package?: string;
+	arguments: DerivedAddressArguments;
+	config?: {
+		accountRegistry: ConfigValue;
+		accountPackageId?: string;
+	};
+}
+/**
+ * Returns the deterministic canonical account address for external discovery and
+ * PTB construction.
+ */
+export function derivedAddress(options: DerivedAddressOptions) {
+	const packageAddress =
+		options.package ?? options.config?.accountPackageId ?? '@local-pkg/account';
+	const argumentsTypes = [null, 'address'] satisfies (string | null)[];
+	const parameterNames = ['registry', 'owner'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'account_registry',
+			function: 'derived_address',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					registry: options.arguments?.registry ?? options.config?.accountRegistry,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface DerivedWrapperAddressArguments {
+	registry?: RawTransactionArgument<string>;
+	owner: RawTransactionArgument<string>;
+}
+export interface DerivedWrapperAddressOptions {
+	package?: string;
+	arguments: DerivedWrapperAddressArguments;
+	config?: {
+		accountRegistry: ConfigValue;
+		accountPackageId?: string;
+	};
+}
+/**
+ * Returns the deterministic wrapper address for external discovery, accumulator
+ * delivery, and PTB construction.
+ */
+export function derivedWrapperAddress(options: DerivedWrapperAddressOptions) {
+	const packageAddress =
+		options.package ?? options.config?.accountPackageId ?? '@local-pkg/account';
+	const argumentsTypes = [null, 'address'] satisfies (string | null)[];
+	const parameterNames = ['registry', 'owner'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'account_registry',
+			function: 'derived_wrapper_address',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					registry: options.arguments?.registry ?? options.config?.accountRegistry,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface DerivedExistsArguments {
+	registry?: RawTransactionArgument<string>;
+	owner: RawTransactionArgument<string>;
+}
+export interface DerivedExistsOptions {
+	package?: string;
+	arguments: DerivedExistsArguments;
+	config?: {
+		accountRegistry: ConfigValue;
+		accountPackageId?: string;
+	};
+}
+/** Returns whether the canonical account identity has been claimed. */
+export function derivedExists(options: DerivedExistsOptions) {
+	const packageAddress =
+		options.package ?? options.config?.accountPackageId ?? '@local-pkg/account';
+	const argumentsTypes = [null, 'address'] satisfies (string | null)[];
+	const parameterNames = ['registry', 'owner'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'account_registry',
+			function: 'derived_exists',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					registry: options.arguments?.registry ?? options.config?.accountRegistry,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface DerivedWrapperExistsArguments {
+	registry?: RawTransactionArgument<string>;
+	owner: RawTransactionArgument<string>;
+}
+export interface DerivedWrapperExistsOptions {
+	package?: string;
+	arguments: DerivedWrapperExistsArguments;
+	config?: {
+		accountRegistry: ConfigValue;
+		accountPackageId?: string;
+	};
+}
+/** Returns whether the canonical wrapper has been claimed. */
+export function derivedWrapperExists(options: DerivedWrapperExistsOptions) {
+	const packageAddress =
+		options.package ?? options.config?.accountPackageId ?? '@local-pkg/account';
+	const argumentsTypes = [null, 'address'] satisfies (string | null)[];
+	const parameterNames = ['registry', 'owner'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'account_registry',
+			function: 'derived_wrapper_exists',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					registry: options.arguments?.registry ?? options.config?.accountRegistry,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface NewArguments {
+	registry?: RawTransactionArgument<string>;
+}
+export interface NewOptions {
+	package?: string;
+	arguments?: NewArguments;
+	config?: {
+		accountRegistry: ConfigValue;
+		accountPackageId?: string;
+	};
+}
+/**
+ * Creates the sender's canonical account and wrapper, aborting if either derived
+ * ID is already claimed.
+ */
+export function _new(options: NewOptions) {
+	const packageAddress =
+		options.package ?? options.config?.accountPackageId ?? '@local-pkg/account';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['registry'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'account_registry',
+			function: 'new',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					registry: options.arguments?.registry ?? options.config?.accountRegistry,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface NewWithReferrerArguments {
+	registry?: RawTransactionArgument<string>;
+	referrer: RawTransactionArgument<string>;
+}
+export interface NewWithReferrerOptions {
+	package?: string;
+	arguments: NewWithReferrerArguments;
+	config?: {
+		accountRegistry: ConfigValue;
+		accountPackageId?: string;
+	};
+}
+/**
+ * Creates the sender's canonical account and permanently records the supplied
+ * wrapper's account identity and receive address as its referrer.
+ */
+export function newWithReferrer(options: NewWithReferrerOptions) {
+	const packageAddress =
+		options.package ?? options.config?.accountPackageId ?? '@local-pkg/account';
+	const argumentsTypes = [null, null] satisfies (string | null)[];
+	const parameterNames = ['registry', 'referrer'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'account_registry',
+			function: 'new_with_referrer',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					registry: options.arguments?.registry ?? options.config?.accountRegistry,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface NewSelfOwnedArguments {
+	registry?: RawTransactionArgument<string>;
+	ownerUid: RawTransactionArgument<string>;
+}
+export interface NewSelfOwnedOptions {
+	package?: string;
+	arguments: NewSelfOwnedArguments;
+	config?: {
+		accountRegistry: ConfigValue;
+		accountPackageId?: string;
+	};
+}
+/**
+ * Creates the canonical account owned by `owner_uid`'s object address, aborting if
+ * either derived ID is already claimed.
+ */
+export function newSelfOwned(options: NewSelfOwnedOptions) {
+	const packageAddress =
+		options.package ?? options.config?.accountPackageId ?? '@local-pkg/account';
+	const argumentsTypes = [null, '0x2::object::ID'] satisfies (string | null)[];
+	const parameterNames = ['registry', 'ownerUid'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'account_registry',
+			function: 'new_self_owned',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					registry: options.arguments?.registry ?? options.config?.accountRegistry,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+		});
+}
+export interface IsAppAuthorizedArguments {
+	registry?: RawTransactionArgument<string>;
+}
+export interface IsAppAuthorizedOptions {
+	package?: string;
+	arguments?: IsAppAuthorizedArguments;
+	config?: {
+		accountRegistry: ConfigValue;
+		accountPackageId?: string;
+	};
+	typeArguments: [string];
+}
+/** Returns whether `App` may request package-issued mutable account authority. */
+export function isAppAuthorized(options: IsAppAuthorizedOptions) {
+	const packageAddress =
+		options.package ?? options.config?.accountPackageId ?? '@local-pkg/account';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['registry'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'account_registry',
+			function: 'is_app_authorized',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					registry: options.arguments?.registry ?? options.config?.accountRegistry,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface AuthorizeAppArguments {
+	registry?: RawTransactionArgument<string>;
+	Cap: RawTransactionArgument<string>;
+}
+export interface AuthorizeAppOptions {
+	package?: string;
+	arguments: AuthorizeAppArguments;
+	config?: {
+		accountRegistry: ConfigValue;
+		accountPackageId?: string;
+	};
+	typeArguments: [string];
+}
+/** Globally authorizes `App` to request mutable authority for account wrappers. */
+export function authorizeApp(options: AuthorizeAppOptions) {
+	const packageAddress =
+		options.package ?? options.config?.accountPackageId ?? '@local-pkg/account';
+	const argumentsTypes = [null, null] satisfies (string | null)[];
+	const parameterNames = ['registry', 'Cap'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'account_registry',
+			function: 'authorize_app',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					registry: options.arguments?.registry ?? options.config?.accountRegistry,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface DeauthorizeAppArguments {
+	registry?: RawTransactionArgument<string>;
+	Cap: RawTransactionArgument<string>;
+}
+export interface DeauthorizeAppOptions {
+	package?: string;
+	arguments: DeauthorizeAppArguments;
+	config?: {
+		accountRegistry: ConfigValue;
+		accountPackageId?: string;
+	};
+	typeArguments: [string];
+}
+/** Revokes `App` from requesting new mutable account authority. */
+export function deauthorizeApp(options: DeauthorizeAppOptions) {
+	const packageAddress =
+		options.package ?? options.config?.accountPackageId ?? '@local-pkg/account';
+	const argumentsTypes = [null, null] satisfies (string | null)[];
+	const parameterNames = ['registry', 'Cap'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'account_registry',
+			function: 'deauthorize_app',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					registry: options.arguments?.registry ?? options.config?.accountRegistry,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface AssertAppIsAuthorizedArguments {
+	registry?: RawTransactionArgument<string>;
+}
+export interface AssertAppIsAuthorizedOptions {
+	package?: string;
+	arguments?: AssertAppIsAuthorizedArguments;
+	config?: {
+		accountRegistry: ConfigValue;
+		accountPackageId?: string;
+	};
+	typeArguments: [string];
+}
+/** Aborts unless `App` is currently authorized for app-driven account access. */
+export function assertAppIsAuthorized(options: AssertAppIsAuthorizedOptions) {
+	const packageAddress =
+		options.package ?? options.config?.accountPackageId ?? '@local-pkg/account';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['registry'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'account_registry',
+			function: 'assert_app_is_authorized',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					registry: options.arguments?.registry ?? options.config?.accountRegistry,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+			typeArguments: options.typeArguments,
+		});
+}
+export interface GenerateAuthAsAppArguments {
+	registry?: RawTransactionArgument<string>;
+	Permit: TransactionArgument;
+}
+export interface GenerateAuthAsAppOptions {
+	package?: string;
+	arguments: GenerateAuthAsAppArguments;
+	config?: {
+		accountRegistry: ConfigValue;
+		accountPackageId?: string;
+	};
+	typeArguments: [string];
+}
+/**
+ * Generates full mutable account authority after checking the global app
+ * whitelist. `Permit<App>` restricts the request to the module that defines `App`;
+ * the returned authority is not bound to an owner, wrapper, or operation.
+ */
+export function generateAuthAsApp(options: GenerateAuthAsAppOptions) {
+	const packageAddress =
+		options.package ?? options.config?.accountPackageId ?? '@local-pkg/account';
+	const argumentsTypes = [null, null] satisfies (string | null)[];
+	const parameterNames = ['registry', 'Permit'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'account_registry',
+			function: 'generate_auth_as_app',
+			arguments: normalizeMoveArguments(
+				{
+					...options.arguments,
+					registry: options.arguments?.registry ?? options.config?.accountRegistry,
+				},
+				argumentsTypes,
+				parameterNames,
+			),
+			typeArguments: options.typeArguments,
+		});
+}

package/src/contracts/account/config-arguments.ts

@@ -0,0 +1,8 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type ConfigValue } from '../utils/index.js';
+export interface AccountConfig {
+	accountPackageId?: string;
+	accountRegistry: ConfigValue;
+}

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

@@ -0,0 +1,42 @@
+/**************************************************************
+ * 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';
+import { U64 } from '../../../../bcs/integers.js';
+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: U64,
+	},
+});

package/src/contracts/deepbook_predict/admin.ts

@@ -0,0 +1,44 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * Defines the root capability used by state-owning modules to authorize Predict
+ * governance operations. Possession is the sole authority; the package exposes no
+ * on-chain revocation or rotation mechanism for this capability.
+ */
+
+import { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction } from '@mysten/sui/transactions';
+const $moduleName = '@local-pkg/deepbook_predict::admin';
+export const AdminCap = new MoveStruct({
+	name: `${$moduleName}::AdminCap`,
+	fields: {
+		id: bcs.Address,
+	},
+});
+export interface IdArguments {
+	cap: RawTransactionArgument<string>;
+}
+export interface IdOptions {
+	package?: string;
+	arguments: IdArguments | [cap: RawTransactionArgument<string>];
+	config?: {
+		predictPackageId?: string;
+	};
+}
+/** Returns the capability identity for administration tooling and object discovery. */
+export function id(options: IdOptions) {
+	const packageAddress =
+		options.package ?? options.config?.predictPackageId ?? '@local-pkg/deepbook_predict';
+	const argumentsTypes = [null] satisfies (string | null)[];
+	const parameterNames = ['cap'];
+	return (tx: Transaction) =>
+		tx.moveCall({
+			package: packageAddress,
+			module: 'admin',
+			function: 'id',
+			arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+		});
+}