@misofm/platform 0.27.0 → 0.28.0

package/src/contracts/routed_stake/routed_stake.ts

@@ -50,21 +50,84 @@ export const RoutedStakeKey = new MoveTuple({ name: `${$moduleName}::RoutedStake
 export const RoutedStakeCreatedEvent = new MoveStruct({ name: `${$moduleName}::RoutedStakeCreatedEvent<phantom StakeShare, phantom PoolShare>`, fields: {
         routed_stake_id: bcs.Address,
         parent_id: bcs.Address,
+        stake_id: bcs.Address,
         staked_value: bcs.u64()
     } });
+export const RoutedStakeSharedEvent = new MoveStruct({ name: `${$moduleName}::RoutedStakeSharedEvent<phantom StakeShare, phantom PoolShare>`, fields: {
+        routed_stake_id: bcs.Address,
+        has_stake: bcs.bool(),
+        stake_id: bcs.Address,
+        staked_value: bcs.u64(),
+        registration_count: bcs.u64()
+    } });
+export const RoutedStakeRegisteredEvent = new MoveStruct({ name: `${$moduleName}::RoutedStakeRegisteredEvent<phantom StakeShare, phantom PoolShare, phantom Currency>`, fields: {
+        routed_stake_id: bcs.Address,
+        parent_id: bcs.Address,
+        stake_id: bcs.Address,
+        stake_pool_id: bcs.Address,
+        staked_value: bcs.u64(),
+        registration_count_before: bcs.u64(),
+        registration_count_after: bcs.u64(),
+        pool_staked_shares_before: bcs.u64(),
+        pool_staked_shares_after: bcs.u64(),
+        pool_cumulative_reward_per_share: bcs.u256(),
+        registration_debt_after: bcs.u256()
+    } });
+export const RoutedStakeUnregisteredEvent = new MoveStruct({ name: `${$moduleName}::RoutedStakeUnregisteredEvent<phantom StakeShare, phantom PoolShare, phantom Currency>`, fields: {
+        routed_stake_id: bcs.Address,
+        parent_id: bcs.Address,
+        stake_id: bcs.Address,
+        stake_pool_id: bcs.Address,
+        staked_value: bcs.u64(),
+        registration_count_before: bcs.u64(),
+        registration_count_after: bcs.u64(),
+        pool_staked_shares_before: bcs.u64(),
+        pool_staked_shares_after: bcs.u64(),
+        pool_cumulative_reward_per_share: bcs.u256(),
+        registration_debt_before: bcs.u256()
+    } });
 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()
+        stake_id: bcs.Address,
+        stake_pool_id: bcs.Address,
+        routed_pool_id: bcs.Address,
+        value: bcs.u64(),
+        /**
+         * `true` when the reward was sent to the routed pool's own address because it had
+         * no stakers to attribute the deposit to; `false` when it was deposited into the
+         * accumulator directly.
+         */
+        parked: bcs.bool(),
+        staked_value: bcs.u64(),
+        source_balance_before: bcs.u64(),
+        source_balance_after: bcs.u64(),
+        source_staked_shares: bcs.u64(),
+        source_index: bcs.u256(),
+        source_carry: bcs.u128(),
+        source_cumulative_deposits: bcs.u128(),
+        registration_debt_before: bcs.u256(),
+        registration_debt_after: bcs.u256(),
+        destination_balance_before: bcs.u64(),
+        destination_balance_after: bcs.u64(),
+        destination_staked_shares: bcs.u64(),
+        destination_index_before: bcs.u256(),
+        destination_index_after: bcs.u256(),
+        destination_carry_before: bcs.u128(),
+        destination_carry_after: bcs.u128(),
+        destination_cumulative_deposits_before: bcs.u128(),
+        destination_cumulative_deposits_after: bcs.u128()
     } });
 export const RoutedStakeUnstakedEvent = new MoveStruct({ name: `${$moduleName}::RoutedStakeUnstakedEvent<phantom StakeShare, phantom PoolShare>`, fields: {
         routed_stake_id: bcs.Address,
         parent_id: bcs.Address,
+        stake_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,
+        stake_id: bcs.Address,
         staked_value: bcs.u64()
     } });
 export interface NewArguments {
@@ -311,15 +374,24 @@ export interface SweepOptions {
  * Claim the wrapped stake's accrued rewards from `stake_pool` and commit them to
  * `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.
+ * `routed_pool`'s address must derive from it (checked first, and always — these
+ * are wrong-object asserts, not "nothing to do"). Returns the value moved,
+ * deposited or parked.
+ *
+ * A crank-facing call never aborts for having nothing to do: `sweep` is a total
+ * no-op — 0 returned, no event — in each of these cases, checked in this order
+ * before touching either pool: the wrapper is empty (`has_stake` false); the
+ * wrapped stake has no registration for `Currency`; or its registration names a
+ * pool other than `stake_pool`. Only once all three pass does it claim from
+ * `stake_pool` — where a zero reward is, again, a no-op.
  *
  * A pool deposit needs a registered stake to attribute to. While `routed_pool` has
  * none, the reward is instead sent to the pool's own address — ordinary
- * address-delivered funds, folded in permissionlessly by `pool::sweep_and_deposit`
- * once a stake registers. Either way the money is committed to the parent's pool,
- * so the route stays fixed and this call — and therefore `unregister`/`unstake` —
- * can never be blocked by the destination's state.
+ * address-delivered funds, folded in permissionlessly by `pool::settle` once a
+ * stake registers (`parked: true` in the emitted event). Either way the money is
+ * committed to the parent's pool, so the route stays fixed and this call — and
+ * therefore `unregister`/`unstake` — can never be blocked by the destination's
+ * state.
  */
 export function sweep(options: SweepOptions) {
     const packageAddress = options.package ?? '@local-pkg/routed_stake';

package/src/contracts/royalty_pool/pool.ts

@@ -29,11 +29,14 @@
  *   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 `sweep_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.
+ *   correctly-typed, shared pool. `recover_coins` and `settle` fold such funds
+ *   into the accumulator, permissionlessly: anyone can complete the delivery. Both
+ *   are total — a crank-facing call never aborts for having nothing to do.
+ *   `settle` folds in what is settled at the pool's own address once stakers
+ *   exist; while `staked_shares == 0` it returns 0 and reads nothing, so funds at
+ *   the pool's address wait, unredeemed, until a stake registers. `recover_coins`
+ *   never deposits — it only converts coin objects into funds at the same address
+ *   for a later `settle` to redeem.
  *
  * ### No activation delay (deliberate)
  *
@@ -95,26 +98,95 @@ export const RoyaltyPool = new MoveStruct({ name: `${$moduleName}::RoyaltyPool<p
 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
+        parent_id: bcs.Address,
+        precision: bcs.u128(),
+        pool_balance_after: bcs.u64(),
+        staked_shares_after: bcs.u64(),
+        cumulative_reward_per_share_after: bcs.u256(),
+        carry_after: bcs.u128(),
+        cumulative_deposits_after: bcs.u128()
+    } });
+export const RoyaltyPoolSharedEvent = new MoveStruct({ name: `${$moduleName}::RoyaltyPoolSharedEvent<phantom Share, phantom Currency>`, fields: {
+        pool_id: bcs.Address,
+        pool_balance_after: bcs.u64(),
+        staked_shares_after: bcs.u64(),
+        cumulative_reward_per_share_after: bcs.u256(),
+        carry_after: bcs.u128(),
+        cumulative_deposits_after: bcs.u128()
     } });
 export const RoyaltyDepositedEvent = new MoveStruct({ name: `${$moduleName}::RoyaltyDepositedEvent<phantom Share, phantom Currency>`, fields: {
         pool_id: bcs.Address,
-        value: bcs.u64()
+        value: bcs.u64(),
+        cumulative_reward_per_share_before: bcs.u256(),
+        carry_before: bcs.u128(),
+        pool_balance_after: bcs.u64(),
+        staked_shares_after: bcs.u64(),
+        cumulative_reward_per_share_after: bcs.u256(),
+        carry_after: bcs.u128(),
+        cumulative_deposits_after: bcs.u128()
+    } });
+export const RoyaltyPoolFundsSettledEvent = new MoveStruct({ name: `${$moduleName}::RoyaltyPoolFundsSettledEvent<phantom Share, phantom Currency>`, fields: {
+        pool_id: bcs.Address,
+        source_address: bcs.Address,
+        accumulator_root_id: bcs.Address,
+        value: bcs.u64(),
+        pool_balance_after: bcs.u64(),
+        staked_shares_after: bcs.u64(),
+        cumulative_reward_per_share_after: bcs.u256(),
+        carry_after: bcs.u128(),
+        cumulative_deposits_after: bcs.u128()
+    } });
+export const RoyaltyPoolCoinsRecoveredEvent = new MoveStruct({ name: `${$moduleName}::RoyaltyPoolCoinsRecoveredEvent<phantom Share, phantom Currency>`, fields: {
+        pool_id: bcs.Address,
+        coin_ids: bcs.vector(bcs.Address),
+        coin_count: bcs.u64(),
+        funds_recipient: bcs.Address,
+        value: bcs.u64(),
+        pool_balance_after: bcs.u64(),
+        staked_shares_after: bcs.u64(),
+        cumulative_reward_per_share_after: bcs.u256(),
+        carry_after: bcs.u128(),
+        cumulative_deposits_after: bcs.u128()
     } });
 export const StakeRegisteredEvent = new MoveStruct({ name: `${$moduleName}::StakeRegisteredEvent<phantom Share, phantom Currency>`, fields: {
         pool_id: bcs.Address,
         stake_id: bcs.Address,
-        staked_amount: bcs.u64()
+        staked_amount: bcs.u64(),
+        registration_debt_after: bcs.u256(),
+        stake_registration_count_after: bcs.u64(),
+        pool_balance_after: bcs.u64(),
+        staked_shares_after: bcs.u64(),
+        cumulative_reward_per_share_after: bcs.u256(),
+        carry_after: bcs.u128(),
+        cumulative_deposits_after: bcs.u128()
     } });
 export const StakeUnregisteredEvent = new MoveStruct({ name: `${$moduleName}::StakeUnregisteredEvent<phantom Share, phantom Currency>`, fields: {
         pool_id: bcs.Address,
         stake_id: bcs.Address,
-        unstaked_amount: bcs.u64()
+        unstaked_amount: bcs.u64(),
+        removed_registration_debt: bcs.u256(),
+        forfeited_reward_numerator: bcs.u256(),
+        stake_registration_count_after: bcs.u64(),
+        pool_balance_after: bcs.u64(),
+        staked_shares_after: bcs.u64(),
+        cumulative_reward_per_share_after: bcs.u256(),
+        carry_after: bcs.u128(),
+        cumulative_deposits_after: bcs.u128()
     } });
 export const RoyaltyClaimedEvent = new MoveStruct({ name: `${$moduleName}::RoyaltyClaimedEvent<phantom Share, phantom Currency>`, fields: {
         pool_id: bcs.Address,
         stake_id: bcs.Address,
-        reward_amount: bcs.u64()
+        staked_amount: bcs.u64(),
+        reward_amount: bcs.u64(),
+        registration_debt_before: bcs.u256(),
+        registration_debt_after: bcs.u256(),
+        reward_residue_after: bcs.u256(),
+        stake_registration_count_after: bcs.u64(),
+        pool_balance_after: bcs.u64(),
+        staked_shares_after: bcs.u64(),
+        cumulative_reward_per_share_after: bcs.u256(),
+        carry_after: bcs.u128(),
+        cumulative_deposits_after: bcs.u128()
     } });
 export interface NewArguments {
     parent: RawTransactionArgument<string>;
@@ -219,15 +291,13 @@ export function deposit(options: DepositOptions) {
         typeArguments: options.typeArguments
     });
 }
-export interface ReceiveAndDepositArguments {
+export interface SettleArguments {
     self: RawTransactionArgument<string>;
-    coins: TransactionArgument;
 }
-export interface ReceiveAndDepositOptions {
+export interface SettleOptions {
     package?: string;
-    arguments: ReceiveAndDepositArguments | [
-        self: RawTransactionArgument<string>,
-        coins: TransactionArgument
+    arguments: SettleArguments | [
+        self: RawTransactionArgument<string>
     ];
     typeArguments: [
         string,
@@ -235,32 +305,36 @@ export interface ReceiveAndDepositOptions {
     ];
 }
 /**
- * Receive `Coin<Currency>` objects sent directly to this pool's address and fold
- * them into the accumulator. Recovery path for funds delivered to the pool's
- * address rather than via the canonical extension path.
+ * Redeem everything settled at this pool's own address and fold it into the
+ * accumulator. Recovery path for funds a routed sweep parked here while the pool
+ * had no stakers. Returns the value deposited. Returns 0 and changes nothing when
+ * nothing is settled or when `staked_shares == 0` (the funds stay at the pool's
+ * address until a stake registers). Permissionless.
  */
-export function receiveAndDeposit(options: ReceiveAndDepositOptions) {
+export function settle(options: SettleOptions) {
     const packageAddress = options.package ?? '@local-pkg/royalty_pool';
     const argumentsTypes = [
         null,
-        'vector<null>'
+        '0x2::accumulator::AccumulatorRoot'
     ] satisfies (string | null)[];
-    const parameterNames = ["self", "coins"];
+    const parameterNames = ["self"];
     return (tx: Transaction) => tx.moveCall({
         package: packageAddress,
         module: 'pool',
-        function: 'receive_and_deposit',
+        function: 'settle',
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
         typeArguments: options.typeArguments
     });
 }
-export interface SweepAndDepositArguments {
+export interface RecoverCoinsArguments {
     self: RawTransactionArgument<string>;
+    coins: TransactionArgument;
 }
-export interface SweepAndDepositOptions {
+export interface RecoverCoinsOptions {
     package?: string;
-    arguments: SweepAndDepositArguments | [
-        self: RawTransactionArgument<string>
+    arguments: RecoverCoinsArguments | [
+        self: RawTransactionArgument<string>,
+        coins: TransactionArgument
     ];
     typeArguments: [
         string,
@@ -268,25 +342,21 @@ export interface SweepAndDepositOptions {
     ];
 }
 /**
- * Redeem the pool's funds settled at the start of the current consensus commit and
- * fold them into the royalty accumulator. Recovery path for funds delivered via
- * Sui's `send_funds` mechanism rather than via the canonical extension path.
- *
- * The framework returns at most `u64::MAX` per call. Any excess, along with funds
- * sent later in the current commit, remains for a subsequent sweep. Aborts with
- * `ENoSettledFunds` when no positive amount is currently eligible.
+ * Convert `Coin` objects sent to this pool's address into funds at the same
+ * address, so `settle` can fold them in next commit. Deposits nothing. Returns the
+ * value converted; 0 for an empty vector. Permissionless.
  */
-export function sweepAndDeposit(options: SweepAndDepositOptions) {
+export function recoverCoins(options: RecoverCoinsOptions) {
     const packageAddress = options.package ?? '@local-pkg/royalty_pool';
     const argumentsTypes = [
         null,
-        '0x2::accumulator::AccumulatorRoot'
+        'vector<null>'
     ] satisfies (string | null)[];
-    const parameterNames = ["self"];
+    const parameterNames = ["self", "coins"];
     return (tx: Transaction) => tx.moveCall({
         package: packageAddress,
         module: 'pool',
-        function: 'sweep_and_deposit',
+        function: 'recover_coins',
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
         typeArguments: options.typeArguments
     });
@@ -569,6 +639,38 @@ export function cumulativeDeposits(options: CumulativeDepositsOptions) {
         typeArguments: options.typeArguments
     });
 }
+export interface SettledValueArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface SettledValueOptions {
+    package?: string;
+    arguments: SettledValueArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Funds of `Currency` settled at this pool's own address as of the start of the
+ * current consensus commit — what `settle` would redeem right now.
+ */
+export function settledValue(options: SettledValueOptions) {
+    const packageAddress = options.package ?? '@local-pkg/royalty_pool';
+    const argumentsTypes = [
+        null,
+        '0x2::accumulator::AccumulatorRoot'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'pool',
+        function: 'settled_value',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
 export interface DerivedAddressArguments {
     parentId: RawTransactionArgument<string>;
 }

package/src/contracts/royalty_pool/stake.ts

@@ -54,11 +54,14 @@ export const Stake = new MoveStruct({ name: `${$moduleName}::Stake<phantom Share
     } });
 export const StakeCreatedEvent = new MoveStruct({ name: `${$moduleName}::StakeCreatedEvent<phantom Share>`, fields: {
         stake_id: bcs.Address,
-        amount: bcs.u64()
+        transaction_sender: bcs.Address,
+        amount: bcs.u64(),
+        registration_count_after: bcs.u64()
     } });
 export const StakeDestroyedEvent = new MoveStruct({ name: `${$moduleName}::StakeDestroyedEvent<phantom Share>`, fields: {
         stake_id: bcs.Address,
-        amount: bcs.u64()
+        amount: bcs.u64(),
+        registration_count_before: bcs.u64()
     } });
 export interface NewArguments {
     balance: TransactionArgument;

package/src/contracts/share/share.ts

@@ -0,0 +1,97 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * Fixed-supply currency issuance for representing equity-like ownership stakes.
+ *
+ * ### Usage:
+ *
+ * 1.  Create a package with a `share` module containing a `Share` type
+ * 2.  Create a currency with `sui::coin_registry::new_currency`
+ * 3.  Delete the metadata cap via `finalize_and_delete_metadata_cap`
+ * 4.  Call `share::share::initialize` with the currency and its canonical treasury
+ *     cap (the one created together with the currency)
+ * 5.  Distribute the returned balance to shareholders
+ */
+
+import { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
+import { type Transaction } from '@mysten/sui/transactions';
+const $moduleName = '@local-pkg/share::share';
+export const ShareInitializedEvent = new MoveStruct({ name: `${$moduleName}::ShareInitializedEvent<phantom ShareType>`, fields: {
+        currency_id: bcs.Address,
+        treasury_cap_id: bcs.Address,
+        share_type: bcs.vector(bcs.u8()),
+        decimals: bcs.u8(),
+        supply: bcs.u64(),
+        fixed_supply: bcs.bool(),
+        metadata_cap_deleted: bcs.bool(),
+        regulated: bcs.bool(),
+        name: bcs.vector(bcs.u8()),
+        symbol: bcs.vector(bcs.u8()),
+        description: bcs.vector(bcs.u8()),
+        icon_url: bcs.vector(bcs.u8())
+    } });
+export interface InitializeArguments {
+    currency: RawTransactionArgument<string>;
+    treasuryCap: RawTransactionArgument<string>;
+}
+export interface InitializeOptions {
+    package?: string;
+    arguments: InitializeArguments | [
+        currency: RawTransactionArgument<string>,
+        treasuryCap: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Initializes a fixed-supply share token with 10,000,000.000000 supply. Validates
+ * the currency configuration, mints the fixed supply, and makes the supply
+ * immutable. Returns the full token balance.
+ *
+ * The type parameter must be a `Share` type defined in a `share` module (i.e.
+ * `<address>::share::Share`).
+ */
+export function initialize(options: InitializeOptions) {
+    const packageAddress = options.package ?? '@local-pkg/share';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["currency", "treasuryCap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'share',
+        function: 'initialize',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface AssertValidShareTypeOptions {
+    package?: string;
+    arguments?: [
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Asserts that the share type name ends with the expected suffix
+ * (`<address>::share::Share`). Public so downstream packages that hold or route
+ * share types (e.g. cap inventories) can enforce the same gate this package's
+ * `initialize` enforces, instead of mirroring it.
+ */
+export function assertValidShareType(options: AssertValidShareTypeOptions) {
+    const packageAddress = options.package ?? '@local-pkg/share';
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'share',
+        function: 'assert_valid_share_type',
+        typeArguments: options.typeArguments
+    });
+}

package/src/contracts/vault/vault.ts

@@ -49,21 +49,72 @@ export const VaultAdminCap = new MoveStruct({ name: `${$moduleName}::VaultAdminC
 export const VaultKey = new MoveTuple({ name: `${$moduleName}::VaultKey<phantom Cap>`, fields: [bcs.Address] });
 export const VaultAdminCapKey = new MoveTuple({ name: `${$moduleName}::VaultAdminCapKey`, fields: [bcs.bool()] });
 export const AuthorizedPluginKey = new MoveTuple({ name: `${$moduleName}::AuthorizedPluginKey<phantom Witness>`, fields: [bcs.bool()] });
+export const VaultRegistryCreatedEvent = new MoveStruct({ name: `${$moduleName}::VaultRegistryCreatedEvent`, fields: {
+        registry_id: bcs.Address,
+        shared: bcs.bool()
+    } });
 export const VaultCreatedEvent = new MoveStruct({ name: `${$moduleName}::VaultCreatedEvent<phantom Cap>`, fields: {
+        registry_id: bcs.Address,
+        vault_id: bcs.Address,
+        cap_id: bcs.Address,
+        admin_cap_id: bcs.Address,
+        authorized_plugins_id: bcs.Address,
+        authorized_plugin_count: bcs.u64(),
+        active: bcs.bool(),
+        capability_available: bcs.bool()
+    } });
+export const VaultSharedEvent = new MoveStruct({ name: `${$moduleName}::VaultSharedEvent<phantom Cap>`, fields: {
         vault_id: bcs.Address,
         cap_id: bcs.Address
     } });
 export const PluginAuthorizedEvent = new MoveStruct({ name: `${$moduleName}::PluginAuthorizedEvent<phantom Cap, phantom Witness>`, fields: {
-        vault_id: bcs.Address
+        vault_id: bcs.Address,
+        cap_id: bcs.Address,
+        admin_cap_id: bcs.Address,
+        authorized_plugins_id: bcs.Address,
+        authorized_plugin_count: bcs.u64(),
+        authorized: bcs.bool()
     } });
 export const PluginRevokedEvent = new MoveStruct({ name: `${$moduleName}::PluginRevokedEvent<phantom Cap, phantom Witness>`, fields: {
-        vault_id: bcs.Address
+        vault_id: bcs.Address,
+        cap_id: bcs.Address,
+        admin_cap_id: bcs.Address,
+        authorized_plugins_id: bcs.Address,
+        authorized_plugin_count: bcs.u64(),
+        authorized: bcs.bool()
     } });
 export const VaultCapabilityWithdrawnEvent = new MoveStruct({ name: `${$moduleName}::VaultCapabilityWithdrawnEvent<phantom Cap>`, fields: {
-        vault_id: bcs.Address
+        vault_id: bcs.Address,
+        cap_id: bcs.Address,
+        admin_cap_id: bcs.Address,
+        active: bcs.bool(),
+        capability_available: bcs.bool()
     } });
 export const VaultCapabilityRestoredEvent = new MoveStruct({ name: `${$moduleName}::VaultCapabilityRestoredEvent<phantom Cap>`, fields: {
-        vault_id: bcs.Address
+        vault_id: bcs.Address,
+        cap_id: bcs.Address,
+        admin_cap_id: bcs.Address,
+        active: bcs.bool(),
+        capability_available: bcs.bool()
+    } });
+export const VaultCapabilityBorrowedByPluginEvent = new MoveStruct({ name: `${$moduleName}::VaultCapabilityBorrowedByPluginEvent<phantom Cap, phantom Witness>`, fields: {
+        vault_id: bcs.Address,
+        cap_id: bcs.Address,
+        active: bcs.bool(),
+        capability_available: bcs.bool()
+    } });
+export const VaultCapabilityBorrowedByAdminEvent = new MoveStruct({ name: `${$moduleName}::VaultCapabilityBorrowedByAdminEvent<phantom Cap>`, fields: {
+        vault_id: bcs.Address,
+        cap_id: bcs.Address,
+        admin_cap_id: bcs.Address,
+        active: bcs.bool(),
+        capability_available: bcs.bool()
+    } });
+export const VaultCapabilityReturnedEvent = new MoveStruct({ name: `${$moduleName}::VaultCapabilityReturnedEvent<phantom Cap>`, fields: {
+        vault_id: bcs.Address,
+        cap_id: bcs.Address,
+        active: bcs.bool(),
+        capability_available: bcs.bool()
     } });
 export interface NewArguments<Cap extends BcsType<any>> {
     registry: RawTransactionArgument<string>;

package/src/contracts.ts

@@ -35,6 +35,24 @@ import * as rawRoyaltyPool from "./contracts/royalty_pool/pool.ts";
 import * as rawRoyaltyStake from "./contracts/royalty_pool/stake.ts";
 import * as rawRoutedStake from "./contracts/routed_stake/routed_stake.ts";
 import * as rawPartyProfile from "./contracts/party_profile/party_profile.ts";
+import * as rawShare from "./contracts/share/share.ts";
+import * as rawPay from "./contracts/miso_pay/pay.ts";
+import * as rawPlatformLink from "./contracts/platform_link/platform_link.ts";
+
+// Generic inputs have no configured platform deployment or client-bound call
+// surface yet. Expose their event codecs through this curated barrel while
+// keeping generated transaction functions available only through the raw
+// wildcard `./contracts/*` subpath.
+export const share = {
+  ShareInitializedEvent: rawShare.ShareInitializedEvent,
+} as const;
+export const pay = {
+  PaymentSentEvent: rawPay.PaymentSentEvent,
+} as const;
+export const platformLink = {
+  PlatformLinkSetEvent: rawPlatformLink.PlatformLinkSetEvent,
+  PlatformLinkRemovedEvent: rawPlatformLink.PlatformLinkRemovedEvent,
+} as const;
 
 // Record identity/issuance and Record Shop primary-sale mechanics. The
 // package-restricted witness constructor is intentionally not exported here.