@haneullabs/deepbook-v3 0.1.0

package/dist/cjs/contracts/deepbook/account.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/contracts/deepbook/account.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\n/** Account module manages the account data for each user. */\n\nimport { MoveStruct, normalizeMoveArguments } from '../utils/index.js';\nimport type { RawTransactionArgument } from '../utils/index.js';\nimport { bcs } from '@haneullabs/haneul/bcs';\nimport type { Transaction } from '@haneullabs/haneul/transactions';\nimport * as vec_set from './deps/sui/vec_set.js';\nimport * as balances from './balances.js';\nconst $moduleName = '@deepbook/core::account';\nexport const Account = new MoveStruct({\n\tname: `${$moduleName}::Account`,\n\tfields: {\n\t\tepoch: bcs.u64(),\n\t\topen_orders: vec_set.VecSet(bcs.u128()),\n\t\ttaker_volume: bcs.u128(),\n\t\tmaker_volume: bcs.u128(),\n\t\tactive_stake: bcs.u64(),\n\t\tinactive_stake: bcs.u64(),\n\t\tcreated_proposal: bcs.bool(),\n\t\tvoted_proposal: bcs.option(bcs.Address),\n\t\tunclaimed_rebates: balances.Balances,\n\t\tsettled_balances: balances.Balances,\n\t\towed_balances: balances.Balances,\n\t},\n});\nexport interface OpenOrdersArguments {\n\tself: RawTransactionArgument<string>;\n}\nexport interface OpenOrdersOptions {\n\tpackage?: string;\n\targuments: OpenOrdersArguments | [self: RawTransactionArgument<string>];\n}\nexport function openOrders(options: OpenOrdersOptions) {\n\tconst packageAddress = options.package ?? '@deepbook/core';\n\tconst argumentsTypes = [`${packageAddress}::account::Account`] satisfies string[];\n\tconst parameterNames = ['self'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'account',\n\t\t\tfunction: 'open_orders',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface TakerVolumeArguments {\n\tself: RawTransactionArgument<string>;\n}\nexport interface TakerVolumeOptions {\n\tpackage?: string;\n\targuments: TakerVolumeArguments | [self: RawTransactionArgument<string>];\n}\nexport function takerVolume(options: TakerVolumeOptions) {\n\tconst packageAddress = options.package ?? '@deepbook/core';\n\tconst argumentsTypes = [`${packageAddress}::account::Account`] satisfies string[];\n\tconst parameterNames = ['self'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'account',\n\t\t\tfunction: 'taker_volume',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface MakerVolumeArguments {\n\tself: RawTransactionArgument<string>;\n}\nexport interface MakerVolumeOptions {\n\tpackage?: string;\n\targuments: MakerVolumeArguments | [self: RawTransactionArgument<string>];\n}\nexport function makerVolume(options: MakerVolumeOptions) {\n\tconst packageAddress = options.package ?? '@deepbook/core';\n\tconst argumentsTypes = [`${packageAddress}::account::Account`] satisfies string[];\n\tconst parameterNames = ['self'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'account',\n\t\t\tfunction: 'maker_volume',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface TotalVolumeArguments {\n\tself: RawTransactionArgument<string>;\n}\nexport interface TotalVolumeOptions {\n\tpackage?: string;\n\targuments: TotalVolumeArguments | [self: RawTransactionArgument<string>];\n}\nexport function totalVolume(options: TotalVolumeOptions) {\n\tconst packageAddress = options.package ?? '@deepbook/core';\n\tconst argumentsTypes = [`${packageAddress}::account::Account`] satisfies string[];\n\tconst parameterNames = ['self'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'account',\n\t\t\tfunction: 'total_volume',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface ActiveStakeArguments {\n\tself: RawTransactionArgument<string>;\n}\nexport interface ActiveStakeOptions {\n\tpackage?: string;\n\targuments: ActiveStakeArguments | [self: RawTransactionArgument<string>];\n}\nexport function activeStake(options: ActiveStakeOptions) {\n\tconst packageAddress = options.package ?? '@deepbook/core';\n\tconst argumentsTypes = [`${packageAddress}::account::Account`] satisfies string[];\n\tconst parameterNames = ['self'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'account',\n\t\t\tfunction: 'active_stake',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface InactiveStakeArguments {\n\tself: RawTransactionArgument<string>;\n}\nexport interface InactiveStakeOptions {\n\tpackage?: string;\n\targuments: InactiveStakeArguments | [self: RawTransactionArgument<string>];\n}\nexport function inactiveStake(options: InactiveStakeOptions) {\n\tconst packageAddress = options.package ?? '@deepbook/core';\n\tconst argumentsTypes = [`${packageAddress}::account::Account`] satisfies string[];\n\tconst parameterNames = ['self'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'account',\n\t\t\tfunction: 'inactive_stake',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface CreatedProposalArguments {\n\tself: RawTransactionArgument<string>;\n}\nexport interface CreatedProposalOptions {\n\tpackage?: string;\n\targuments: CreatedProposalArguments | [self: RawTransactionArgument<string>];\n}\nexport function createdProposal(options: CreatedProposalOptions) {\n\tconst packageAddress = options.package ?? '@deepbook/core';\n\tconst argumentsTypes = [`${packageAddress}::account::Account`] satisfies string[];\n\tconst parameterNames = ['self'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'account',\n\t\t\tfunction: 'created_proposal',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface VotedProposalArguments {\n\tself: RawTransactionArgument<string>;\n}\nexport interface VotedProposalOptions {\n\tpackage?: string;\n\targuments: VotedProposalArguments | [self: RawTransactionArgument<string>];\n}\nexport function votedProposal(options: VotedProposalOptions) {\n\tconst packageAddress = options.package ?? '@deepbook/core';\n\tconst argumentsTypes = [`${packageAddress}::account::Account`] satisfies string[];\n\tconst parameterNames = ['self'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'account',\n\t\t\tfunction: 'voted_proposal',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\nexport interface SettledBalancesArguments {\n\tself: RawTransactionArgument<string>;\n}\nexport interface SettledBalancesOptions {\n\tpackage?: string;\n\targuments: SettledBalancesArguments | [self: RawTransactionArgument<string>];\n}\nexport function settledBalances(options: SettledBalancesOptions) {\n\tconst packageAddress = options.package ?? '@deepbook/core';\n\tconst argumentsTypes = [`${packageAddress}::account::Account`] satisfies string[];\n\tconst parameterNames = ['self'];\n\treturn (tx: Transaction) =>\n\t\ttx.moveCall({\n\t\t\tpackage: packageAddress,\n\t\t\tmodule: 'account',\n\t\t\tfunction: 'settled_balances',\n\t\t\targuments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),\n\t\t});\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,mBAAmD;AAEnD,iBAAoB;AAEpB,cAAyB;AACzB,eAA0B;AAC1B,MAAM,cAAc;AACb,MAAM,UAAU,IAAI,wBAAW;AAAA,EACrC,MAAM,GAAG,WAAW;AAAA,EACpB,QAAQ;AAAA,IACP,OAAO,eAAI,IAAI;AAAA,IACf,aAAa,QAAQ,OAAO,eAAI,KAAK,CAAC;AAAA,IACtC,cAAc,eAAI,KAAK;AAAA,IACvB,cAAc,eAAI,KAAK;AAAA,IACvB,cAAc,eAAI,IAAI;AAAA,IACtB,gBAAgB,eAAI,IAAI;AAAA,IACxB,kBAAkB,eAAI,KAAK;AAAA,IAC3B,gBAAgB,eAAI,OAAO,eAAI,OAAO;AAAA,IACtC,mBAAmB,SAAS;AAAA,IAC5B,kBAAkB,SAAS;AAAA,IAC3B,eAAe,SAAS;AAAA,EACzB;AACD,CAAC;AAQM,SAAS,WAAW,SAA4B;AACtD,QAAM,iBAAiB,QAAQ,WAAW;AAC1C,QAAM,iBAAiB,CAAC,GAAG,cAAc,oBAAoB;AAC7D,QAAM,iBAAiB,CAAC,MAAM;AAC9B,SAAO,CAAC,OACP,GAAG,SAAS;AAAA,IACX,SAAS;AAAA,IACT,QAAQ;AAAA,IACR,UAAU;AAAA,IACV,eAAW,qCAAuB,QAAQ,WAAW,gBAAgB,cAAc;AAAA,EACpF,CAAC;AACH;AAQO,SAAS,YAAY,SAA6B;AACxD,QAAM,iBAAiB,QAAQ,WAAW;AAC1C,QAAM,iBAAiB,CAAC,GAAG,cAAc,oBAAoB;AAC7D,QAAM,iBAAiB,CAAC,MAAM;AAC9B,SAAO,CAAC,OACP,GAAG,SAAS;AAAA,IACX,SAAS;AAAA,IACT,QAAQ;AAAA,IACR,UAAU;AAAA,IACV,eAAW,qCAAuB,QAAQ,WAAW,gBAAgB,cAAc;AAAA,EACpF,CAAC;AACH;AAQO,SAAS,YAAY,SAA6B;AACxD,QAAM,iBAAiB,QAAQ,WAAW;AAC1C,QAAM,iBAAiB,CAAC,GAAG,cAAc,oBAAoB;AAC7D,QAAM,iBAAiB,CAAC,MAAM;AAC9B,SAAO,CAAC,OACP,GAAG,SAAS;AAAA,IACX,SAAS;AAAA,IACT,QAAQ;AAAA,IACR,UAAU;AAAA,IACV,eAAW,qCAAuB,QAAQ,WAAW,gBAAgB,cAAc;AAAA,EACpF,CAAC;AACH;AAQO,SAAS,YAAY,SAA6B;AACxD,QAAM,iBAAiB,QAAQ,WAAW;AAC1C,QAAM,iBAAiB,CAAC,GAAG,cAAc,oBAAoB;AAC7D,QAAM,iBAAiB,CAAC,MAAM;AAC9B,SAAO,CAAC,OACP,GAAG,SAAS;AAAA,IACX,SAAS;AAAA,IACT,QAAQ;AAAA,IACR,UAAU;AAAA,IACV,eAAW,qCAAuB,QAAQ,WAAW,gBAAgB,cAAc;AAAA,EACpF,CAAC;AACH;AAQO,SAAS,YAAY,SAA6B;AACxD,QAAM,iBAAiB,QAAQ,WAAW;AAC1C,QAAM,iBAAiB,CAAC,GAAG,cAAc,oBAAoB;AAC7D,QAAM,iBAAiB,CAAC,MAAM;AAC9B,SAAO,CAAC,OACP,GAAG,SAAS;AAAA,IACX,SAAS;AAAA,IACT,QAAQ;AAAA,IACR,UAAU;AAAA,IACV,eAAW,qCAAuB,QAAQ,WAAW,gBAAgB,cAAc;AAAA,EACpF,CAAC;AACH;AAQO,SAAS,cAAc,SAA+B;AAC5D,QAAM,iBAAiB,QAAQ,WAAW;AAC1C,QAAM,iBAAiB,CAAC,GAAG,cAAc,oBAAoB;AAC7D,QAAM,iBAAiB,CAAC,MAAM;AAC9B,SAAO,CAAC,OACP,GAAG,SAAS;AAAA,IACX,SAAS;AAAA,IACT,QAAQ;AAAA,IACR,UAAU;AAAA,IACV,eAAW,qCAAuB,QAAQ,WAAW,gBAAgB,cAAc;AAAA,EACpF,CAAC;AACH;AAQO,SAAS,gBAAgB,SAAiC;AAChE,QAAM,iBAAiB,QAAQ,WAAW;AAC1C,QAAM,iBAAiB,CAAC,GAAG,cAAc,oBAAoB;AAC7D,QAAM,iBAAiB,CAAC,MAAM;AAC9B,SAAO,CAAC,OACP,GAAG,SAAS;AAAA,IACX,SAAS;AAAA,IACT,QAAQ;AAAA,IACR,UAAU;AAAA,IACV,eAAW,qCAAuB,QAAQ,WAAW,gBAAgB,cAAc;AAAA,EACpF,CAAC;AACH;AAQO,SAAS,cAAc,SAA+B;AAC5D,QAAM,iBAAiB,QAAQ,WAAW;AAC1C,QAAM,iBAAiB,CAAC,GAAG,cAAc,oBAAoB;AAC7D,QAAM,iBAAiB,CAAC,MAAM;AAC9B,SAAO,CAAC,OACP,GAAG,SAAS;AAAA,IACX,SAAS;AAAA,IACT,QAAQ;AAAA,IACR,UAAU;AAAA,IACV,eAAW,qCAAuB,QAAQ,WAAW,gBAAgB,cAAc;AAAA,EACpF,CAAC;AACH;AAQO,SAAS,gBAAgB,SAAiC;AAChE,QAAM,iBAAiB,QAAQ,WAAW;AAC1C,QAAM,iBAAiB,CAAC,GAAG,cAAc,oBAAoB;AAC7D,QAAM,iBAAiB,CAAC,MAAM;AAC9B,SAAO,CAAC,OACP,GAAG,SAAS;AAAA,IACX,SAAS;AAAA,IACT,QAAQ;AAAA,IACR,UAAU;AAAA,IACV,eAAW,qCAAuB,QAAQ,WAAW,gBAAgB,cAAc;AAAA,EACpF,CAAC;AACH;",
+  "names": []
+}

package/dist/cjs/contracts/deepbook/balance_manager.d.ts

@@ -0,0 +1,268 @@
+/**
+ * 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 type { RawTransactionArgument } from '../utils/index.js';
+import type { Transaction } from '@haneullabs/haneul/transactions';
+export declare const BalanceManager: MoveStruct<{
+    id: MoveStruct<{
+        id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+    owner: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    balances: MoveStruct<{
+        id: MoveStruct<{
+            id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        }, "0x2::object::UID">;
+        size: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "0x2::bag::Bag">;
+    allow_listed: MoveStruct<{
+        contents: import("@haneullabs/haneul/bcs").BcsType<string[], Iterable<string | Uint8Array<ArrayBufferLike>> & {
+            length: number;
+        }, string>;
+    }, "0x2::vec_set::VecSet<bytes[32]>">;
+}, "@deepbook/core::balance_manager::BalanceManager">;
+export declare const BalanceManagerEvent: MoveStruct<{
+    balance_manager_id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    owner: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+}, "@deepbook/core::balance_manager::BalanceManagerEvent">;
+export declare const BalanceEvent: MoveStruct<{
+    balance_manager_id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    asset: MoveStruct<{
+        name: import("@haneullabs/haneul/bcs").BcsType<string, string, "string">;
+    }, "std::type_name::TypeName">;
+    amount: import("@haneullabs/haneul/bcs").BcsType<string, string | number | bigint, "u64">;
+    deposit: import("@haneullabs/haneul/bcs").BcsType<boolean, boolean, "bool">;
+}, "@deepbook/core::balance_manager::BalanceEvent">;
+export declare const BalanceKey: MoveStruct<{
+    dummy_field: import("@haneullabs/haneul/bcs").BcsType<boolean, boolean, "bool">;
+}, "@deepbook/core::balance_manager::BalanceKey">;
+export declare const TradeCap: MoveStruct<{
+    id: MoveStruct<{
+        id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+    balance_manager_id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+}, "@deepbook/core::balance_manager::TradeCap">;
+export declare const DepositCap: MoveStruct<{
+    id: MoveStruct<{
+        id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+    balance_manager_id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+}, "@deepbook/core::balance_manager::DepositCap">;
+export declare const WithdrawCap: MoveStruct<{
+    id: MoveStruct<{
+        id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+    balance_manager_id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+}, "@deepbook/core::balance_manager::WithdrawCap">;
+export declare const TradeProof: MoveStruct<{
+    balance_manager_id: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    trader: import("@haneullabs/haneul/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+}, "@deepbook/core::balance_manager::TradeProof">;
+export interface NewOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function _new(options?: NewOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface NewWithOwnerArguments {
+    Owner: RawTransactionArgument<string>;
+}
+export interface NewWithOwnerOptions {
+    package?: string;
+    arguments: NewWithOwnerArguments | [Owner: RawTransactionArgument<string>];
+}
+export declare function newWithOwner(options: NewWithOwnerOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface NewWithCustomOwnerArguments {
+    owner: RawTransactionArgument<string>;
+}
+export interface NewWithCustomOwnerOptions {
+    package?: string;
+    arguments: NewWithCustomOwnerArguments | [owner: RawTransactionArgument<string>];
+}
+/** Create a new balance manager with an owner. */
+export declare function newWithCustomOwner(options: NewWithCustomOwnerOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface NewWithCustomOwnerAndCapsArguments {
+    owner: RawTransactionArgument<string>;
+}
+export interface NewWithCustomOwnerAndCapsOptions {
+    package?: string;
+    arguments: NewWithCustomOwnerAndCapsArguments | [owner: RawTransactionArgument<string>];
+}
+export declare function newWithCustomOwnerAndCaps(options: NewWithCustomOwnerAndCapsOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface BalanceArguments {
+    balanceManager: RawTransactionArgument<string>;
+}
+export interface BalanceOptions {
+    package?: string;
+    arguments: BalanceArguments | [balanceManager: RawTransactionArgument<string>];
+    typeArguments: [string];
+}
+/** Returns the balance of a Coin in a balance manager. */
+export declare function balance(options: BalanceOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface MintTradeCapArguments {
+    balanceManager: RawTransactionArgument<string>;
+}
+export interface MintTradeCapOptions {
+    package?: string;
+    arguments: MintTradeCapArguments | [balanceManager: RawTransactionArgument<string>];
+}
+/** Mint a `TradeCap`, only owner can mint a `TradeCap`. */
+export declare function mintTradeCap(options: MintTradeCapOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface MintDepositCapArguments {
+    balanceManager: RawTransactionArgument<string>;
+}
+export interface MintDepositCapOptions {
+    package?: string;
+    arguments: MintDepositCapArguments | [balanceManager: RawTransactionArgument<string>];
+}
+/** Mint a `DepositCap`, only owner can mint. */
+export declare function mintDepositCap(options: MintDepositCapOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface MintWithdrawCapArguments {
+    balanceManager: RawTransactionArgument<string>;
+}
+export interface MintWithdrawCapOptions {
+    package?: string;
+    arguments: MintWithdrawCapArguments | [balanceManager: RawTransactionArgument<string>];
+}
+/** Mint a `WithdrawCap`, only owner can mint. */
+export declare function mintWithdrawCap(options: MintWithdrawCapOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface RevokeTradeCapArguments {
+    balanceManager: RawTransactionArgument<string>;
+    tradeCapId: RawTransactionArgument<string>;
+}
+export interface RevokeTradeCapOptions {
+    package?: string;
+    arguments: RevokeTradeCapArguments | [balanceManager: RawTransactionArgument<string>, tradeCapId: RawTransactionArgument<string>];
+}
+/**
+ * Revoke a `TradeCap`. Only the owner can revoke a `TradeCap`. Can also be used to
+ * revoke `DepositCap` and `WithdrawCap`.
+ */
+export declare function revokeTradeCap(options: RevokeTradeCapOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface GenerateProofAsOwnerArguments {
+    balanceManager: RawTransactionArgument<string>;
+}
+export interface GenerateProofAsOwnerOptions {
+    package?: string;
+    arguments: GenerateProofAsOwnerArguments | [balanceManager: RawTransactionArgument<string>];
+}
+/**
+ * Generate a `TradeProof` by the owner. The owner does not require a capability
+ * and can generate TradeProofs without the risk of equivocation.
+ */
+export declare function generateProofAsOwner(options: GenerateProofAsOwnerOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface GenerateProofAsTraderArguments {
+    balanceManager: RawTransactionArgument<string>;
+    tradeCap: RawTransactionArgument<string>;
+}
+export interface GenerateProofAsTraderOptions {
+    package?: string;
+    arguments: GenerateProofAsTraderArguments | [balanceManager: RawTransactionArgument<string>, tradeCap: RawTransactionArgument<string>];
+}
+/**
+ * Generate a `TradeProof` with a `TradeCap`. Risk of equivocation since `TradeCap`
+ * is an owned object.
+ */
+export declare function generateProofAsTrader(options: GenerateProofAsTraderOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface DepositArguments {
+    balanceManager: RawTransactionArgument<string>;
+    coin: RawTransactionArgument<string>;
+}
+export interface DepositOptions {
+    package?: string;
+    arguments: DepositArguments | [balanceManager: RawTransactionArgument<string>, coin: RawTransactionArgument<string>];
+    typeArguments: [string];
+}
+/** Deposit funds to a balance manager. Only owner can call this directly. */
+export declare function deposit(options: DepositOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface DepositWithCapArguments {
+    balanceManager: RawTransactionArgument<string>;
+    depositCap: RawTransactionArgument<string>;
+    coin: RawTransactionArgument<string>;
+}
+export interface DepositWithCapOptions {
+    package?: string;
+    arguments: DepositWithCapArguments | [
+        balanceManager: RawTransactionArgument<string>,
+        depositCap: RawTransactionArgument<string>,
+        coin: RawTransactionArgument<string>
+    ];
+    typeArguments: [string];
+}
+/** Deposit funds into a balance manager by a `DepositCap` owner. */
+export declare function depositWithCap(options: DepositWithCapOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface WithdrawWithCapArguments {
+    balanceManager: RawTransactionArgument<string>;
+    withdrawCap: RawTransactionArgument<string>;
+    withdrawAmount: RawTransactionArgument<number | bigint>;
+}
+export interface WithdrawWithCapOptions {
+    package?: string;
+    arguments: WithdrawWithCapArguments | [
+        balanceManager: RawTransactionArgument<string>,
+        withdrawCap: RawTransactionArgument<string>,
+        withdrawAmount: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [string];
+}
+/** Withdraw funds from a balance manager by a `WithdrawCap` owner. */
+export declare function withdrawWithCap(options: WithdrawWithCapOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface WithdrawArguments {
+    balanceManager: RawTransactionArgument<string>;
+    withdrawAmount: RawTransactionArgument<number | bigint>;
+}
+export interface WithdrawOptions {
+    package?: string;
+    arguments: WithdrawArguments | [
+        balanceManager: RawTransactionArgument<string>,
+        withdrawAmount: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [string];
+}
+/**
+ * Withdraw funds from a balance_manager. Only owner can call this directly. If
+ * withdraw_all is true, amount is ignored and full balance withdrawn. If
+ * withdraw_all is false, withdraw_amount will be withdrawn.
+ */
+export declare function withdraw(options: WithdrawOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface WithdrawAllArguments {
+    balanceManager: RawTransactionArgument<string>;
+}
+export interface WithdrawAllOptions {
+    package?: string;
+    arguments: WithdrawAllArguments | [balanceManager: RawTransactionArgument<string>];
+    typeArguments: [string];
+}
+export declare function withdrawAll(options: WithdrawAllOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface ValidateProofArguments {
+    balanceManager: RawTransactionArgument<string>;
+    proof: RawTransactionArgument<string>;
+}
+export interface ValidateProofOptions {
+    package?: string;
+    arguments: ValidateProofArguments | [balanceManager: RawTransactionArgument<string>, proof: RawTransactionArgument<string>];
+}
+export declare function validateProof(options: ValidateProofOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface OwnerArguments {
+    balanceManager: RawTransactionArgument<string>;
+}
+export interface OwnerOptions {
+    package?: string;
+    arguments: OwnerArguments | [balanceManager: RawTransactionArgument<string>];
+}
+/** Returns the owner of the balance_manager. */
+export declare function owner(options: OwnerOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;
+export interface IdArguments {
+    balanceManager: RawTransactionArgument<string>;
+}
+export interface IdOptions {
+    package?: string;
+    arguments: IdArguments | [balanceManager: RawTransactionArgument<string>];
+}
+/** Returns the owner of the balance_manager. */
+export declare function id(options: IdOptions): (tx: Transaction) => import("@haneullabs/haneul/transactions").TransactionResult;

package/dist/cjs/contracts/deepbook/balance_manager.js

@@ -0,0 +1,361 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var balance_manager_exports = {};
+__export(balance_manager_exports, {
+  BalanceEvent: () => BalanceEvent,
+  BalanceKey: () => BalanceKey,
+  BalanceManager: () => BalanceManager,
+  BalanceManagerEvent: () => BalanceManagerEvent,
+  DepositCap: () => DepositCap,
+  TradeCap: () => TradeCap,
+  TradeProof: () => TradeProof,
+  WithdrawCap: () => WithdrawCap,
+  _new: () => _new,
+  balance: () => balance,
+  deposit: () => deposit,
+  depositWithCap: () => depositWithCap,
+  generateProofAsOwner: () => generateProofAsOwner,
+  generateProofAsTrader: () => generateProofAsTrader,
+  id: () => id,
+  mintDepositCap: () => mintDepositCap,
+  mintTradeCap: () => mintTradeCap,
+  mintWithdrawCap: () => mintWithdrawCap,
+  newWithCustomOwner: () => newWithCustomOwner,
+  newWithCustomOwnerAndCaps: () => newWithCustomOwnerAndCaps,
+  newWithOwner: () => newWithOwner,
+  owner: () => owner,
+  revokeTradeCap: () => revokeTradeCap,
+  validateProof: () => validateProof,
+  withdraw: () => withdraw,
+  withdrawAll: () => withdrawAll,
+  withdrawWithCap: () => withdrawWithCap
+});
+module.exports = __toCommonJS(balance_manager_exports);
+var import_utils = require("../utils/index.js");
+var import_bcs = require("@haneullabs/haneul/bcs");
+var object = __toESM(require("./deps/sui/object.js"));
+var bag = __toESM(require("./deps/sui/bag.js"));
+var vec_set = __toESM(require("./deps/sui/vec_set.js"));
+var type_name = __toESM(require("./deps/std/type_name.js"));
+const $moduleName = "@deepbook/core::balance_manager";
+const BalanceManager = new import_utils.MoveStruct({
+  name: `${$moduleName}::BalanceManager`,
+  fields: {
+    id: object.UID,
+    owner: import_bcs.bcs.Address,
+    balances: bag.Bag,
+    allow_listed: vec_set.VecSet(import_bcs.bcs.Address)
+  }
+});
+const BalanceManagerEvent = new import_utils.MoveStruct({
+  name: `${$moduleName}::BalanceManagerEvent`,
+  fields: {
+    balance_manager_id: import_bcs.bcs.Address,
+    owner: import_bcs.bcs.Address
+  }
+});
+const BalanceEvent = new import_utils.MoveStruct({
+  name: `${$moduleName}::BalanceEvent`,
+  fields: {
+    balance_manager_id: import_bcs.bcs.Address,
+    asset: type_name.TypeName,
+    amount: import_bcs.bcs.u64(),
+    deposit: import_bcs.bcs.bool()
+  }
+});
+const BalanceKey = new import_utils.MoveStruct({
+  name: `${$moduleName}::BalanceKey`,
+  fields: {
+    dummy_field: import_bcs.bcs.bool()
+  }
+});
+const TradeCap = new import_utils.MoveStruct({
+  name: `${$moduleName}::TradeCap`,
+  fields: {
+    id: object.UID,
+    balance_manager_id: import_bcs.bcs.Address
+  }
+});
+const DepositCap = new import_utils.MoveStruct({
+  name: `${$moduleName}::DepositCap`,
+  fields: {
+    id: object.UID,
+    balance_manager_id: import_bcs.bcs.Address
+  }
+});
+const WithdrawCap = new import_utils.MoveStruct({
+  name: `${$moduleName}::WithdrawCap`,
+  fields: {
+    id: object.UID,
+    balance_manager_id: import_bcs.bcs.Address
+  }
+});
+const TradeProof = new import_utils.MoveStruct({
+  name: `${$moduleName}::TradeProof`,
+  fields: {
+    balance_manager_id: import_bcs.bcs.Address,
+    trader: import_bcs.bcs.Address
+  }
+});
+function _new(options = {}) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "balance_manager",
+    function: "new"
+  });
+}
+function newWithOwner(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = ["address"];
+  const parameterNames = ["Owner"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "balance_manager",
+    function: "new_with_owner",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function newWithCustomOwner(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = ["address"];
+  const parameterNames = ["owner"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "balance_manager",
+    function: "new_with_custom_owner",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function newWithCustomOwnerAndCaps(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = ["address"];
+  const parameterNames = ["owner"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "balance_manager",
+    function: "new_with_custom_owner_and_caps",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function balance(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [`${packageAddress}::balance_manager::BalanceManager`];
+  const parameterNames = ["balanceManager"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "balance_manager",
+    function: "balance",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function mintTradeCap(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [`${packageAddress}::balance_manager::BalanceManager`];
+  const parameterNames = ["balanceManager"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "balance_manager",
+    function: "mint_trade_cap",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function mintDepositCap(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [`${packageAddress}::balance_manager::BalanceManager`];
+  const parameterNames = ["balanceManager"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "balance_manager",
+    function: "mint_deposit_cap",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function mintWithdrawCap(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [`${packageAddress}::balance_manager::BalanceManager`];
+  const parameterNames = ["balanceManager"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "balance_manager",
+    function: "mint_withdraw_cap",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function revokeTradeCap(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::balance_manager::BalanceManager`,
+    "0x0000000000000000000000000000000000000000000000000000000000000002::object::ID"
+  ];
+  const parameterNames = ["balanceManager", "tradeCapId"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "balance_manager",
+    function: "revoke_trade_cap",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function generateProofAsOwner(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [`${packageAddress}::balance_manager::BalanceManager`];
+  const parameterNames = ["balanceManager"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "balance_manager",
+    function: "generate_proof_as_owner",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function generateProofAsTrader(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::balance_manager::BalanceManager`,
+    `${packageAddress}::balance_manager::TradeCap`
+  ];
+  const parameterNames = ["balanceManager", "tradeCap"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "balance_manager",
+    function: "generate_proof_as_trader",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function deposit(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::balance_manager::BalanceManager`,
+    `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${options.typeArguments[0]}>`
+  ];
+  const parameterNames = ["balanceManager", "coin"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "balance_manager",
+    function: "deposit",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function depositWithCap(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::balance_manager::BalanceManager`,
+    `${packageAddress}::balance_manager::DepositCap`,
+    `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${options.typeArguments[0]}>`
+  ];
+  const parameterNames = ["balanceManager", "depositCap", "coin"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "balance_manager",
+    function: "deposit_with_cap",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function withdrawWithCap(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::balance_manager::BalanceManager`,
+    `${packageAddress}::balance_manager::WithdrawCap`,
+    "u64"
+  ];
+  const parameterNames = ["balanceManager", "withdrawCap", "withdrawAmount"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "balance_manager",
+    function: "withdraw_with_cap",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function withdraw(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::balance_manager::BalanceManager`,
+    "u64"
+  ];
+  const parameterNames = ["balanceManager", "withdrawAmount"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "balance_manager",
+    function: "withdraw",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function withdrawAll(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [`${packageAddress}::balance_manager::BalanceManager`];
+  const parameterNames = ["balanceManager"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "balance_manager",
+    function: "withdraw_all",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function validateProof(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [
+    `${packageAddress}::balance_manager::BalanceManager`,
+    `${packageAddress}::balance_manager::TradeProof`
+  ];
+  const parameterNames = ["balanceManager", "proof"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "balance_manager",
+    function: "validate_proof",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function owner(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [`${packageAddress}::balance_manager::BalanceManager`];
+  const parameterNames = ["balanceManager"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "balance_manager",
+    function: "owner",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+function id(options) {
+  const packageAddress = options.package ?? "@deepbook/core";
+  const argumentsTypes = [`${packageAddress}::balance_manager::BalanceManager`];
+  const parameterNames = ["balanceManager"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "balance_manager",
+    function: "id",
+    arguments: (0, import_utils.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames)
+  });
+}
+//# sourceMappingURL=balance_manager.js.map