@misofm/sdk 0.9.0 → 0.11.0

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])
+        } });
+}

package/src/contracts/vault/vault.ts

@@ -0,0 +1,454 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * Generic capability custody and plugin authorization.
+ * 
+ * `Vault<Cap>` holds a capability in a Sui `Referent`. An authorized plugin
+ * receives the whole capability temporarily, paired with a hot-potato `Borrow`
+ * receipt that forces the same capability back into the same vault before the
+ * transaction can finish. Plugin authorization is represented by a typed dynamic
+ * field in the vault's `Bag`.
+ */
+
+import { type BcsType, bcs } from '@mysten/sui/bcs';
+import { MoveStruct, MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+import * as borrow from './deps/sui/borrow.js';
+import * as bag from './deps/sui/bag.js';
+const $moduleName = '@local-pkg/vault::vault';
+/**
+ * Custodies one capability and the typed authorization records for plugins.
+ *
+ * `Vault` intentionally lacks `store`: only this module can share or destroy it.
+ * The wrapped capability is never exposed except through a hot-potato borrow that
+ * requires its exact return.
+ */
+export function Vault<Cap extends BcsType<any>>(...typeParameters: [
+    Cap
+]) {
+    return new MoveStruct({ name: `${$moduleName}::Vault<${typeParameters[0].name as Cap['name']}>`, fields: {
+            id: bcs.Address,
+            cap: borrow.Referent(typeParameters[0]),
+            authorized_plugins: bag.Bag
+        } });
+}
+export const VaultAdminCap = new MoveStruct({ name: `${$moduleName}::VaultAdminCap<phantom Cap>`, fields: {
+        id: bcs.Address,
+        vault_id: bcs.Address
+    } });
+export const AuthorizedPluginKey = new MoveTuple({ name: `${$moduleName}::AuthorizedPluginKey<phantom Witness>`, fields: [bcs.bool()] });
+export const VaultCreatedEvent = new MoveStruct({ name: `${$moduleName}::VaultCreatedEvent<phantom Cap>`, fields: {
+        vault_id: bcs.Address,
+        vault_admin_cap_id: bcs.Address,
+        wrapped_cap_id: bcs.Address,
+        authorized_plugins_id: bcs.Address
+    } });
+export const PluginAuthorizedEvent = new MoveStruct({ name: `${$moduleName}::PluginAuthorizedEvent<phantom Cap, phantom Witness>`, fields: {
+        vault_id: bcs.Address
+    } });
+export const PluginRevokedEvent = new MoveStruct({ name: `${$moduleName}::PluginRevokedEvent<phantom Cap, phantom Witness>`, fields: {
+        vault_id: bcs.Address
+    } });
+export const VaultDestroyedEvent = new MoveStruct({ name: `${$moduleName}::VaultDestroyedEvent<phantom Cap>`, fields: {
+        vault_id: bcs.Address,
+        wrapped_cap_id: bcs.Address
+    } });
+export interface NewArguments<Cap extends BcsType<any>> {
+    cap: RawTransactionArgument<Cap>;
+}
+export interface NewOptions<Cap extends BcsType<any>> {
+    package?: string;
+    arguments: NewArguments<Cap> | [
+        cap: RawTransactionArgument<Cap>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Custody `cap` and create its vault-specific administrator capability. */
+export function _new<Cap extends BcsType<any>>(options: NewOptions<Cap>) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        `${options.typeArguments[0]}`
+    ] satisfies (string | null)[];
+    const parameterNames = ["cap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'new',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface ShareArguments {
+    vault: RawTransactionArgument<string>;
+}
+export interface ShareOptions {
+    package?: string;
+    arguments: ShareArguments | [
+        vault: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Share a newly-created vault. */
+export function share(options: ShareOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'share',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface DestroyArguments {
+    self: RawTransactionArgument<string>;
+    adminCap: RawTransactionArgument<string>;
+}
+export interface DestroyOptions {
+    package?: string;
+    arguments: DestroyArguments | [
+        self: RawTransactionArgument<string>,
+        adminCap: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Destroy an empty vault and return the exact capability it custodied. */
+export function destroy(options: DestroyOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "adminCap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'destroy',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface AuthorizePluginArguments<Witness extends BcsType<any>> {
+    self: RawTransactionArgument<string>;
+    adminCap: RawTransactionArgument<string>;
+    _: RawTransactionArgument<Witness>;
+}
+export interface AuthorizePluginOptions<Witness extends BcsType<any>> {
+    package?: string;
+    arguments: AuthorizePluginArguments<Witness> | [
+        self: RawTransactionArgument<string>,
+        adminCap: RawTransactionArgument<string>,
+        _: RawTransactionArgument<Witness>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Authorize the package identified by its canonical `witness::Witness` type.
+ *
+ * The witness is consumed here. A plugin should construct it with a package-only
+ * `witness::new()` function.
+ */
+export function authorizePlugin<Witness extends BcsType<any>>(options: AuthorizePluginOptions<Witness>) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null,
+        null,
+        `${options.typeArguments[1]}`
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "adminCap", "_"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'authorize_plugin',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface RevokePluginArguments {
+    self: RawTransactionArgument<string>;
+    adminCap: RawTransactionArgument<string>;
+}
+export interface RevokePluginOptions {
+    package?: string;
+    arguments: RevokePluginArguments | [
+        self: RawTransactionArgument<string>,
+        adminCap: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Revoke a plugin authorization without requiring cooperation from the plugin. */
+export function revokePlugin(options: RevokePluginOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "adminCap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'revoke_plugin',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface BorrowAsPluginArguments<Witness extends BcsType<any>> {
+    self: RawTransactionArgument<string>;
+    _: RawTransactionArgument<Witness>;
+}
+export interface BorrowAsPluginOptions<Witness extends BcsType<any>> {
+    package?: string;
+    arguments: BorrowAsPluginArguments<Witness> | [
+        self: RawTransactionArgument<string>,
+        _: RawTransactionArgument<Witness>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Temporarily lend the full custodied capability to an authorized plugin.
+ *
+ * `Borrow` has no abilities, so the exact capability must be returned through
+ * `put_back` in this transaction.
+ */
+export function borrowAsPlugin<Witness extends BcsType<any>>(options: BorrowAsPluginOptions<Witness>) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null,
+        `${options.typeArguments[1]}`
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "_"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'borrow_as_plugin',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface BorrowAsAdminArguments {
+    self: RawTransactionArgument<string>;
+    adminCap: RawTransactionArgument<string>;
+}
+export interface BorrowAsAdminOptions {
+    package?: string;
+    arguments: BorrowAsAdminArguments | [
+        self: RawTransactionArgument<string>,
+        adminCap: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Temporarily lend the full custodied capability to the vault administrator. */
+export function borrowAsAdmin(options: BorrowAsAdminOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "adminCap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'borrow_as_admin',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface PutBackArguments<Cap extends BcsType<any>> {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<Cap>;
+    receipt: TransactionArgument;
+}
+export interface PutBackOptions<Cap extends BcsType<any>> {
+    package?: string;
+    arguments: PutBackArguments<Cap> | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<Cap>,
+        receipt: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Return the exact capability borrowed from this vault.
+ *
+ * No additional authorization is required: `Borrow` proves the originating
+ * referent and capability object ID, and blocking return would harm liveness.
+ */
+export function putBack<Cap extends BcsType<any>>(options: PutBackOptions<Cap>) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null,
+        `${options.typeArguments[0]}`,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "receipt"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'put_back',
+        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
+    ];
+}
+export function id(options: IdOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface VaultIdArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface VaultIdOptions {
+    package?: string;
+    arguments: VaultIdArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export function vaultId(options: VaultIdOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'vault_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface AuthorizedPluginsIdArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface AuthorizedPluginsIdOptions {
+    package?: string;
+    arguments: AuthorizedPluginsIdArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** The ID under which `AuthorizedPluginKey` records are dynamic fields. */
+export function authorizedPluginsId(options: AuthorizedPluginsIdOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'authorized_plugins_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface AuthorizedPluginCountArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface AuthorizedPluginCountOptions {
+    package?: string;
+    arguments: AuthorizedPluginCountArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export function authorizedPluginCount(options: AuthorizedPluginCountOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'authorized_plugin_count',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface IsPluginAuthorizedArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface IsPluginAuthorizedOptions {
+    package?: string;
+    arguments: IsPluginAuthorizedArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Returns whether this witness type has an authorization record.
+ *
+ * This deliberately does not validate the witness shape: arbitrary types simply
+ * report false, while `authorize_plugin` is the only way to add one.
+ */
+export function isPluginAuthorized(options: IsPluginAuthorizedOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'is_plugin_authorized',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}

package/src/contracts.ts

@@ -14,24 +14,31 @@ export * as pressing from "./contracts/miso_pressing/pressing.ts";
 export * as listing from "./contracts/miso_pressing/listing.ts";
 export * as certificate from "./contracts/miso_pressing/certificate.ts";
 
-// The canonical release-id derivation parent — the only PTB-callable path to
-// minting a `Release` now that core's `release::new` takes `&mut UID`.
-export * as releaseRegistry from "./contracts/release_registry/release_registry.ts";
-
-// Existing launch drops remain readable and purchasable while releases move to
-// the pressing/listing contracts.
-export * as drop from "./contracts/miso_drop/drop.ts";
-
-// Royalty-pool extension (base lib + per-work extensions).
+// Generic royalty-pool primitive plus vault-custodied business-logic plugins.
 export * as royaltyPool from "./contracts/royalty_pool/pool.ts";
 export * as royaltyPoolStake from "./contracts/royalty_pool/stake.ts";
+export * as vault from "./contracts/vault/vault.ts";
 export * as compositionRoyaltyPool from "./contracts/composition_royalty_pool/composition_royalty_pool.ts";
 export * as recordingRoyaltyPool from "./contracts/recording_royalty_pool/recording_royalty_pool.ts";
+export * as routedStake from "./contracts/routed_stake/routed_stake.ts";
+export * as compositionRoutedStake from "./contracts/composition_routed_stake/composition_routed_stake.ts";
 
 // Cover art (the CoverArt value type + the release attachment extension).
 export * as coverArt from "./contracts/cover_art/cover_art.ts";
 export * as releaseCoverArt from "./contracts/release_cover_art/release_cover_art.ts";
 
+// Release presentation, discovery, buyer-content, and runtime economics.
+export * as genre from "./contracts/genre/genre.ts";
+export * as releaseDescription from "./contracts/release_description/release_description.ts";
+export * as releaseDspLink from "./contracts/release_dsp_link/release_dsp_link.ts";
+export * as releaseGenre from "./contracts/release_genre/release_genre.ts";
+export * as releaseKind from "./contracts/release_kind/release_kind.ts";
+export * as releaseRevenueDistributor from "./contracts/release_revenue_distributor/release_revenue_distributor.ts";
+export * as recordingAdvisory from "./contracts/recording_advisory/recording_advisory.ts";
+export * as recordingLanguage from "./contracts/recording_language/recording_language.ts";
+export * as recordingMasterReference from "./contracts/recording_master_reference/recording_master_reference.ts";
+export * as recordingPreview from "./contracts/recording_preview/recording_preview.ts";
+
 // Credits extensions (per-work credit stores + their role vocabularies).
 export * as compositionCredits from "./contracts/composition_credits/composition_credits.ts";
 export * as compositionPartyRole from "./contracts/composition_credits/composition_party_role.ts";