@misofm/sdk 0.9.0 → 0.10.0

package/src/contracts/routed_stake/routed_stake.ts

@@ -0,0 +1,508 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * A stake whose rewards are irrevocably routed to its parent's royalty pool.
+ * 
+ * A `RoutedStake<StakeShare, PoolShare>` is a derived object of any UID-bearing
+ * parent (same pattern as `RoyaltyPool`). It wraps a `Stake<StakeShare>` — shares
+ * of some other asset that the parent owns — and commits the rewards that stake
+ * earns to the parent's own `RoyaltyPool<PoolShare, Currency>`: `sweep` is the
+ * only reachable claim path, and it deposits straight into the pool derived from
+ * the same parent. The wrapper exists precisely so the raw `Stake` is never
+ * exposed — a bare shared `Stake` would let any caller claim its rewards and keep
+ * them.
+ * 
+ * Because the route is fixed, the wrapper is safe to share: `sweep` is
+ * permissionless, and it does not matter who calls it, since the money can only go
+ * one place. Lifecycle operations (`register`, `unregister`, `unstake`, `restake`)
+ * instead require the parent's `&mut UID` as the credential — cap-gating happens
+ * at the parent, exactly as with `RoyaltyPool` creation. `register`/`unregister`
+ * are gated because a stake registers at most once per `Currency`: a
+ * permissionless register could grief by binding the stake to a garbage same-typed
+ * pool, permanently blocking the real one for that currency.
+ * 
+ * The derivation key encodes only `StakeShare` — at most one routed stake per
+ * `(parent, StakeShare)` pair, whatever `PoolShare` it used (the same
+ * burned-by-first-claim consequence as `RoyaltyPoolKey`; the parent's cap-gated
+ * extension is expected to pin `PoolShare` to the parent's own share type). For
+ * the same reason the wrapper is never deleted: `unstake` empties it and `restake`
+ * refills it, so the one derived address per pair stays usable forever.
+ */
+
+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 stake_1 from './deps/royalty_pool/stake.js';
+const $moduleName = '@local-pkg/routed_stake::routed_stake';
+export const RoutedStake = new MoveStruct({ name: `${$moduleName}::RoutedStake<phantom StakeShare, phantom PoolShare>`, fields: {
+        id: bcs.Address,
+        /**
+         * The wrapped position. `None` between `unstake` and `restake`; the wrapper itself
+         * persists because its derived address can never be re-claimed.
+         */
+        stake: bcs.option(stake_1.Stake)
+    } });
+export const RoutedStakeKey = new MoveTuple({ name: `${$moduleName}::RoutedStakeKey<phantom StakeShare>`, fields: [bcs.bool()] });
+export const RoutedStakeCreatedEvent = new MoveStruct({ name: `${$moduleName}::RoutedStakeCreatedEvent<phantom StakeShare, phantom PoolShare>`, fields: {
+        routed_stake_id: bcs.Address,
+        parent_id: bcs.Address,
+        staked_value: bcs.u64()
+    } });
+export const RoutedStakeSweptEvent = new MoveStruct({ name: `${$moduleName}::RoutedStakeSweptEvent<phantom StakeShare, phantom PoolShare, phantom Currency>`, fields: {
+        routed_stake_id: bcs.Address,
+        parent_id: bcs.Address,
+        value: bcs.u64()
+    } });
+export const RoutedStakeUnstakedEvent = new MoveStruct({ name: `${$moduleName}::RoutedStakeUnstakedEvent<phantom StakeShare, phantom PoolShare>`, fields: {
+        routed_stake_id: bcs.Address,
+        parent_id: bcs.Address,
+        unstaked_value: bcs.u64()
+    } });
+export const RoutedStakeRestakedEvent = new MoveStruct({ name: `${$moduleName}::RoutedStakeRestakedEvent<phantom StakeShare, phantom PoolShare>`, fields: {
+        routed_stake_id: bcs.Address,
+        parent_id: bcs.Address,
+        staked_value: bcs.u64()
+    } });
+export interface NewArguments {
+    parent: RawTransactionArgument<string>;
+    balance: TransactionArgument;
+}
+export interface NewOptions {
+    package?: string;
+    arguments: NewArguments | [
+        parent: RawTransactionArgument<string>,
+        balance: TransactionArgument
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Construct a routed stake as a derived object of `parent`, wrapping `balance` as
+ * its staked position. Aborts (in `stake::new`) on a zero balance, and (in
+ * `derived_object::claim`) if the `(parent, StakeShare)` address was already
+ * claimed.
+ *
+ * Cap-gating happens at the parent: callers must obtain `&mut UID` via whatever
+ * cap-gated accessor the parent exposes.
+ */
+export function _new(options: NewOptions) {
+    const packageAddress = options.package ?? '@local-pkg/routed_stake';
+    const argumentsTypes = [
+        '0x2::object::ID',
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["parent", "balance"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'routed_stake',
+        function: 'new',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface ShareArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface ShareOptions {
+    package?: string;
+    arguments: ShareArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Share the routed stake so anyone can `sweep` it. */
+export function share(options: ShareOptions) {
+    const packageAddress = options.package ?? '@local-pkg/routed_stake';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'routed_stake',
+        function: 'share',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface RegisterArguments {
+    self: RawTransactionArgument<string>;
+    parent: RawTransactionArgument<string>;
+    stakePool: RawTransactionArgument<string>;
+}
+export interface RegisterOptions {
+    package?: string;
+    arguments: RegisterArguments | [
+        self: RawTransactionArgument<string>,
+        parent: RawTransactionArgument<string>,
+        stakePool: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string,
+        string
+    ];
+}
+/**
+ * Register the wrapped stake with the pool it earns from, so future deposits
+ * accrue to it. Which same-typed pool is the _correct_ one is the caller's concern
+ * — the parent's extension is expected to pin it (e.g. by derivation from the
+ * asset object) before delegating here.
+ */
+export function register(options: RegisterOptions) {
+    const packageAddress = options.package ?? '@local-pkg/routed_stake';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID',
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "parent", "stakePool"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'routed_stake',
+        function: 'register',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface UnregisterArguments {
+    self: RawTransactionArgument<string>;
+    parent: RawTransactionArgument<string>;
+    stakePool: RawTransactionArgument<string>;
+}
+export interface UnregisterOptions {
+    package?: string;
+    arguments: UnregisterArguments | [
+        self: RawTransactionArgument<string>,
+        parent: RawTransactionArgument<string>,
+        stakePool: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string,
+        string
+    ];
+}
+/**
+ * Unregister the wrapped stake from a pool it earns from. The pool requires
+ * claimable rewards to be drained to zero first — i.e. a final `sweep` — so
+ * accrued rewards provably reach the parent's pool before the position can move.
+ */
+export function unregister(options: UnregisterOptions) {
+    const packageAddress = options.package ?? '@local-pkg/routed_stake';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID',
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "parent", "stakePool"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'routed_stake',
+        function: 'unregister',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface UnstakeArguments {
+    self: RawTransactionArgument<string>;
+    parent: RawTransactionArgument<string>;
+}
+export interface UnstakeOptions {
+    package?: string;
+    arguments: UnstakeArguments | [
+        self: RawTransactionArgument<string>,
+        parent: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Remove the staked position and return its principal. Aborts (in
+ * `stake::destroy`) while any pool registrations remain. The emptied wrapper
+ * persists — its derived address is burned forever, so deleting it would
+ * permanently destroy the parent's ability to route-stake this share type;
+ * `restake` refills it instead.
+ */
+export function unstake(options: UnstakeOptions) {
+    const packageAddress = options.package ?? '@local-pkg/routed_stake';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "parent"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'routed_stake',
+        function: 'unstake',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface RestakeArguments {
+    self: RawTransactionArgument<string>;
+    parent: RawTransactionArgument<string>;
+    balance: TransactionArgument;
+}
+export interface RestakeOptions {
+    package?: string;
+    arguments: RestakeArguments | [
+        self: RawTransactionArgument<string>,
+        parent: RawTransactionArgument<string>,
+        balance: TransactionArgument
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Refill an emptied wrapper with a new staked position. Aborts if a position is
+ * already present.
+ */
+export function restake(options: RestakeOptions) {
+    const packageAddress = options.package ?? '@local-pkg/routed_stake';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID',
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "parent", "balance"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'routed_stake',
+        function: 'restake',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface SweepArguments {
+    self: RawTransactionArgument<string>;
+    stakePool: RawTransactionArgument<string>;
+    routedPool: RawTransactionArgument<string>;
+    parentId: RawTransactionArgument<string>;
+}
+export interface SweepOptions {
+    package?: string;
+    arguments: SweepArguments | [
+        self: RawTransactionArgument<string>,
+        stakePool: RawTransactionArgument<string>,
+        routedPool: RawTransactionArgument<string>,
+        parentId: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string,
+        string
+    ];
+}
+/**
+ * Claim the wrapped stake's accrued rewards from `stake_pool` and deposit them
+ * into `routed_pool` — the parent's own pool. Permissionless: the caller supplies
+ * `parent_id`, but cannot lie, because both the wrapper's own address and
+ * `routed_pool`'s address must derive from it. A zero reward is a no-op (no
+ * event), so the call composes safely into batch PTBs; a positive reward aborts
+ * (in `royalty_pool::pool`) if `routed_pool` has no registered stakes — the reward
+ * stays claimable here until it does.
+ */
+export function sweep(options: SweepOptions) {
+    const packageAddress = options.package ?? '@local-pkg/routed_stake';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        '0x2::object::ID'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "stakePool", "routedPool", "parentId"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'routed_stake',
+        function: 'sweep',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface IdArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface IdOptions {
+    package?: string;
+    arguments: IdArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export function id(options: IdOptions) {
+    const packageAddress = options.package ?? '@local-pkg/routed_stake';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'routed_stake',
+        function: 'id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface HasStakeArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface HasStakeOptions {
+    package?: string;
+    arguments: HasStakeArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export function hasStake(options: HasStakeOptions) {
+    const packageAddress = options.package ?? '@local-pkg/routed_stake';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'routed_stake',
+        function: 'has_stake',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface ValueArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface ValueOptions {
+    package?: string;
+    arguments: ValueArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Staked principal, or 0 while the wrapper is empty. */
+export function value(options: ValueOptions) {
+    const packageAddress = options.package ?? '@local-pkg/routed_stake';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'routed_stake',
+        function: 'value',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface StakeArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface StakeOptions {
+    package?: string;
+    arguments: StakeArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Read-only access to the wrapped stake, e.g. for `pool::pending_rewards`. Aborts
+ * while the wrapper is empty (`has_stake` to guard).
+ */
+export function stake(options: StakeOptions) {
+    const packageAddress = options.package ?? '@local-pkg/routed_stake';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'routed_stake',
+        function: 'stake',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface DerivedAddressArguments {
+    parentId: RawTransactionArgument<string>;
+}
+export interface DerivedAddressOptions {
+    package?: string;
+    arguments: DerivedAddressArguments | [
+        parentId: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Compute the deterministic address of a routed stake given its parent ID and
+ * `StakeShare` type parameter.
+ */
+export function derivedAddress(options: DerivedAddressOptions) {
+    const packageAddress = options.package ?? '@local-pkg/routed_stake';
+    const argumentsTypes = [
+        '0x2::object::ID'
+    ] satisfies (string | null)[];
+    const parameterNames = ["parentId"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'routed_stake',
+        function: 'derived_address',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface AssertDerivedFromArguments {
+    self: RawTransactionArgument<string>;
+    parentId: RawTransactionArgument<string>;
+}
+export interface AssertDerivedFromOptions {
+    package?: string;
+    arguments: AssertDerivedFromArguments | [
+        self: RawTransactionArgument<string>,
+        parentId: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Verify the routed stake was derived from the given parent ID. */
+export function assertDerivedFrom(options: AssertDerivedFromOptions) {
+    const packageAddress = options.package ?? '@local-pkg/routed_stake';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "parentId"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'routed_stake',
+        function: 'assert_derived_from',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}

package/src/contracts/royalty_pool/pool.ts

@@ -5,30 +5,38 @@
 
 /**
  * Accumulator-based royalty distribution pool for the protocol's share tokens.
- * 
+ *
  * A `RoyaltyPool<Share, Currency>` is a derived object of any UID-bearing parent.
- * Its address is deterministically derived from `(parent_id, Currency)` — at most
- * one pool per `(parent, Currency)` pair. The `Share` phantom identifies which
- * share-token type can stake against the pool.
- * 
+ * Its address is deterministically derived from `(parent_id, Share, Currency)` —
+ * at most one pool per triple, and the pool at that address is necessarily typed
+ * `RoyaltyPool<Share, Currency>` (the same type parameters produce the address and
+ * the object) and necessarily shared (the pool is key-only; `share` is its only
+ * consumer). The `Share` phantom identifies which share-token type can stake
+ * against the pool.
+ *
  * Holders create a `Stake<Share>` (see `royalty_pool::stake`) and register it.
  * Callers fund the pool by handing it a `Balance<Currency>` via `deposit`; the
  * accumulator advances and claims pay out the per-stake proportional share since
  * each stake's last claim.
- * 
- * `receive_and_deposit` and `redeem_and_deposit` exist as recovery valves for
- * funds that land directly at the pool's address — either pending `Coin<Currency>`
- * transfers or balances credited to the pool's funds-accumulator. Both are
- * permissionless: anyone who notices stuck funds can fold them in. The canonical
- * funding path remains `deposit(balance)` from a higher-layer extension (e.g.
- * `composition_royalty_distributor`) that pulls from the parent's address. Note
- * the recovery valves run through `deposit`, which aborts while no shares are
- * staked — and the pool has no other withdrawal path — so funds sent to the pool's
- * address before the first registration stay locked until a stake registers.
- * Payers should always target the parent's address, never the pool's.
- * 
+ *
+ * The pool is funded two ways, both committing the funds to share holders:
+ *
+ * - `deposit(balance)` from any caller holding `&mut` on the pool — e.g.
+ *   `routed_stake::sweep`, which deposits a wrapped stake's claimed rewards into
+ *   its parent's pool.
+ * - Delivery to the pool's derived address — pending `Coin<Currency>` transfers or
+ *   address-balance credits (e.g. `release_revenue_distributor` settles each
+ *   track's split there). The address is a pure function of
+ *   `(parent_id, Share, Currency)`, so senders need the pool neither shared nor
+ *   even created yet; a later `new` claims exactly that ID — and can only be the
+ *   correctly-typed, shared pool. `receive_and_deposit` and `redeem_and_deposit`
+ *   fold such funds into the accumulator, permissionlessly: anyone can complete
+ *   the delivery. Both run through `deposit`, which aborts while no shares are
+ *   staked — and the pool has no other withdrawal path — so funds at the pool's
+ *   address wait, locked, until the pool exists and a stake registers.
+ *
  * ### No activation delay (deliberate)
- * 
+ *
  * Registration earns from the next deposit onward; there is no bonding or
  * unbonding period (contrast Sui native staking's next-epoch activation). With the
  * protocol's fixed-supply share token this is safe: a stake's take of any deposit
@@ -37,9 +45,9 @@
  * supply on every deposit. Short-lived or just-in-time registrations can only
  * compete for the _unregistered_ supply's drift — the designed incentive for being
  * registered — never below any registered stake's floor.
- * 
+ *
  * ### Precision
- * 
+ *
  * The share token's shape is fixed at issuance by the protocol — exactly 10¹³ base
  * units, 6 decimals, supply made immutable via `miso_share::share::initialize`
  * (`make_supply_fixed`) — so `staked_shares ≤ 10¹³` objectively. A deposit of
@@ -66,7 +74,7 @@ export const RoyaltyPool = new MoveStruct({ name: `${$moduleName}::RoyaltyPool<p
          */
         cumulative_deposits: bcs.u128()
     } });
-export const RoyaltyPoolKey = new MoveTuple({ name: `${$moduleName}::RoyaltyPoolKey<phantom Currency>`, fields: [bcs.bool()] });
+export const RoyaltyPoolKey = new MoveTuple({ name: `${$moduleName}::RoyaltyPoolKey<phantom Share, phantom Currency>`, fields: [bcs.bool()] });
 export const RoyaltyPoolCreatedEvent = new MoveStruct({ name: `${$moduleName}::RoyaltyPoolCreatedEvent<phantom Share, phantom Currency>`, fields: {
         pool_id: bcs.Address,
         parent_id: bcs.Address
@@ -104,9 +112,10 @@ export interface NewOptions {
     ];
 }
 /**
- * Construct a pool as a derived object of `parent`. The derivation key includes
- * only the `Currency` `TypeName`, so the pool's address is determined entirely by
- * `(parent_id, Currency)`.
+ * Construct a pool as a derived object of `parent`. The derivation key encodes
+ * both type parameters, so the pool's address is determined entirely by
+ * `(parent_id, Share, Currency)` — and therefore always names a pool of exactly
+ * this type (see `RoyaltyPoolKey`).
  *
  * Cap-gating happens at the parent: callers must obtain `&mut UID` via whatever
  * cap-gated accessor the parent exposes.
@@ -548,6 +557,7 @@ export interface DerivedAddressOptions {
         parentId: RawTransactionArgument<string>
     ];
     typeArguments: [
+        string,
         string
     ];
 }

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

@@ -0,0 +1,39 @@
+/**************************************************************
+ * 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/vault/deps/sui/borrow.ts

@@ -0,0 +1,25 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * A simple library that enables hot-potato-locked borrow mechanics.
+ * 
+ * With Programmable transactions, it is possible to borrow a value within a
+ * transaction, use it and put back in the end. Hot-potato `Borrow` makes sure the
+ * object is returned and was not swapped for another one.
+ */
+
+import { type BcsType, bcs } from '@mysten/sui/bcs';
+import { MoveStruct } from '../../../utils/index.js';
+const $moduleName = '0x2::borrow';
+/** An object wrapping a `T` and providing the borrow API. */
+export function Referent<T extends BcsType<any>>(...typeParameters: [
+    T
+]) {
+    return new MoveStruct({ name: `${$moduleName}::Referent<${typeParameters[0].name as T['name']}>`, fields: {
+            id: bcs.Address,
+            value: bcs.option(typeParameters[0])
+        } });
+}