@misofm/sdk 0.15.11 → 0.17.0

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

@@ -5,13 +5,14 @@
 
 /**
  * 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 type {} from "@mysten/bcs";
 import { MoveStruct } from '../../../utils/index.js';
 const $moduleName = '0x2::borrow';
 /** An object wrapping a `T` and providing the borrow API. */

package/src/contracts/vault/vault.ts

@@ -5,7 +5,7 @@
 
 /**
  * Generic capability custody and plugin authorization.
- * 
+ *
  * `Vault<Cap>` is a permanent, deterministically addressed shell that can hold one
  * exact capability in a Sui `Referent`. An authorized plugin receives the whole
  * capability temporarily, paired with a hot-potato `Borrow` receipt that forces
@@ -16,6 +16,7 @@
 
 import { MoveStruct, MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
 import { bcs, type BcsType } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
 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';
@@ -48,14 +49,9 @@ 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
-    } });
 export const VaultCreatedEvent = new MoveStruct({ name: `${$moduleName}::VaultCreatedEvent<phantom Cap>`, fields: {
         vault_id: bcs.Address,
-        vault_admin_cap_id: bcs.Address,
-        cap_id: bcs.Address,
-        authorized_plugins_id: bcs.Address
+        cap_id: bcs.Address
     } });
 export const PluginAuthorizedEvent = new MoveStruct({ name: `${$moduleName}::PluginAuthorizedEvent<phantom Cap, phantom Witness>`, fields: {
         vault_id: bcs.Address
@@ -64,12 +60,10 @@ export const PluginRevokedEvent = new MoveStruct({ name: `${$moduleName}::Plugin
         vault_id: bcs.Address
     } });
 export const VaultCapabilityWithdrawnEvent = new MoveStruct({ name: `${$moduleName}::VaultCapabilityWithdrawnEvent<phantom Cap>`, fields: {
-        vault_id: bcs.Address,
-        cap_id: bcs.Address
+        vault_id: bcs.Address
     } });
 export const VaultCapabilityRestoredEvent = new MoveStruct({ name: `${$moduleName}::VaultCapabilityRestoredEvent<phantom Cap>`, fields: {
-        vault_id: bcs.Address,
-        cap_id: bcs.Address
+        vault_id: bcs.Address
     } });
 export interface NewArguments<Cap extends BcsType<any>> {
     registry: RawTransactionArgument<string>;
@@ -131,39 +125,6 @@ export function share(options: ShareOptions) {
         typeArguments: options.typeArguments
     });
 }
-export interface TransferAdminCapArguments {
-    adminCap: RawTransactionArgument<string>;
-    recipient: RawTransactionArgument<string>;
-}
-export interface TransferAdminCapOptions {
-    package?: string;
-    arguments: TransferAdminCapArguments | [
-        adminCap: RawTransactionArgument<string>,
-        recipient: RawTransactionArgument<string>
-    ];
-    typeArguments: [
-        string
-    ];
-}
-/**
- * Transfer exclusive administration without exposing public freeze, share, or
- * wrapping operations for the VaultAdminCap.
- */
-export function transferAdminCap(options: TransferAdminCapOptions) {
-    const packageAddress = options.package ?? '@local-pkg/vault';
-    const argumentsTypes = [
-        null,
-        'address'
-    ] satisfies (string | null)[];
-    const parameterNames = ["adminCap", "recipient"];
-    return (tx: Transaction) => tx.moveCall({
-        package: packageAddress,
-        module: 'vault',
-        function: 'transfer_admin_cap',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-        typeArguments: options.typeArguments
-    });
-}
 export interface WithdrawCapArguments {
     self: RawTransactionArgument<string>;
     adminCap: RawTransactionArgument<string>;
@@ -250,12 +211,7 @@ export interface AuthorizePluginOptions<Witness extends BcsType<any>> {
         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.
- */
+/** Authorize the plugin identified by this witness type. */
 export function authorizePlugin<Witness extends BcsType<any>>(options: AuthorizePluginOptions<Witness>) {
     const packageAddress = options.package ?? '@local-pkg/vault';
     const argumentsTypes = [
@@ -322,8 +278,7 @@ export interface BorrowAsPluginOptions<Witness extends BcsType<any>> {
  * 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. Aborts if the supplied type is not the exact
- * non-generic `0xpkg::witness::Witness` shape or is not authorized on this Vault.
+ * `put_back` in this transaction.
  */
 export function borrowAsPlugin<Witness extends BcsType<any>>(options: BorrowAsPluginOptions<Witness>) {
     const packageAddress = options.package ?? '@local-pkg/vault';
@@ -408,13 +363,13 @@ export function putBack<Cap extends BcsType<any>>(options: PutBackOptions<Cap>)
         typeArguments: options.typeArguments
     });
 }
-export interface VaultAddressArguments {
+export interface DerivedAddressArguments {
     registry: RawTransactionArgument<string>;
     capId: RawTransactionArgument<string>;
 }
-export interface VaultAddressOptions {
+export interface DerivedAddressOptions {
     package?: string;
-    arguments: VaultAddressArguments | [
+    arguments: DerivedAddressArguments | [
         registry: RawTransactionArgument<string>,
         capId: RawTransactionArgument<string>
     ];
@@ -423,7 +378,7 @@ export interface VaultAddressOptions {
     ];
 }
 /** Derive the canonical Vault address for `cap_id` in this registry. */
-export function vaultAddress(options: VaultAddressOptions) {
+export function derivedAddress(options: DerivedAddressOptions) {
     const packageAddress = options.package ?? '@local-pkg/vault';
     const argumentsTypes = [
         null,
@@ -433,56 +388,7 @@ export function vaultAddress(options: VaultAddressOptions) {
     return (tx: Transaction) => tx.moveCall({
         package: packageAddress,
         module: 'vault',
-        function: 'vault_address',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-        typeArguments: options.typeArguments
-    });
-}
-export interface VaultAdminCapAddressArguments {
-    vaultId: RawTransactionArgument<string>;
-}
-export interface VaultAdminCapAddressOptions {
-    package?: string;
-    arguments: VaultAdminCapAddressArguments | [
-        vaultId: RawTransactionArgument<string>
-    ];
-}
-/** Derive the canonical VaultAdminCap address for a Vault ID. */
-export function vaultAdminCapAddress(options: VaultAdminCapAddressOptions) {
-    const packageAddress = options.package ?? '@local-pkg/vault';
-    const argumentsTypes = [
-        '0x2::object::ID'
-    ] satisfies (string | null)[];
-    const parameterNames = ["vaultId"];
-    return (tx: Transaction) => tx.moveCall({
-        package: packageAddress,
-        module: 'vault',
-        function: 'vault_admin_cap_address',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-    });
-}
-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',
+        function: 'derived_address',
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
         typeArguments: options.typeArguments
     });
@@ -514,12 +420,12 @@ export function capId(options: CapIdOptions) {
         typeArguments: options.typeArguments
     });
 }
-export interface IsOccupiedArguments {
+export interface IsActiveArguments {
     self: RawTransactionArgument<string>;
 }
-export interface IsOccupiedOptions {
+export interface IsActiveOptions {
     package?: string;
-    arguments: IsOccupiedArguments | [
+    arguments: IsActiveArguments | [
         self: RawTransactionArgument<string>
     ];
     typeArguments: [
@@ -527,39 +433,12 @@ export interface IsOccupiedOptions {
     ];
 }
 /**
- * Whether the permanent outer capability slot is occupied.
+ * Whether this Vault is active.
  *
- * This is the persistent-state custody view. It remains true during a
- * transaction-local lease even though the inner Referent is temporarily empty.
+ * An active Vault has an outer Referent. It remains active during a
+ * transaction-local lease even though that Referent is temporarily empty.
  */
-export function isOccupied(options: IsOccupiedOptions) {
-    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_occupied',
-        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) {
+export function isActive(options: IsActiveOptions) {
     const packageAddress = options.package ?? '@local-pkg/vault';
     const argumentsTypes = [
         null
@@ -568,24 +447,25 @@ export function authorizedPluginsId(options: AuthorizedPluginsIdOptions) {
     return (tx: Transaction) => tx.moveCall({
         package: packageAddress,
         module: 'vault',
-        function: 'authorized_plugins_id',
+        function: 'is_active',
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
         typeArguments: options.typeArguments
     });
 }
-export interface AuthorizedPluginCountArguments {
+export interface AuthorizedPluginsArguments {
     self: RawTransactionArgument<string>;
 }
-export interface AuthorizedPluginCountOptions {
+export interface AuthorizedPluginsOptions {
     package?: string;
-    arguments: AuthorizedPluginCountArguments | [
+    arguments: AuthorizedPluginsArguments | [
         self: RawTransactionArgument<string>
     ];
     typeArguments: [
         string
     ];
 }
-export function authorizedPluginCount(options: AuthorizedPluginCountOptions) {
+/** The immutable Bag containing typed plugin-authorization records. */
+export function authorizedPlugins(options: AuthorizedPluginsOptions) {
     const packageAddress = options.package ?? '@local-pkg/vault';
     const argumentsTypes = [
         null
@@ -594,7 +474,7 @@ export function authorizedPluginCount(options: AuthorizedPluginCountOptions) {
     return (tx: Transaction) => tx.moveCall({
         package: packageAddress,
         module: 'vault',
-        function: 'authorized_plugin_count',
+        function: 'authorized_plugins',
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
         typeArguments: options.typeArguments
     });
@@ -612,12 +492,7 @@ export interface IsPluginAuthorizedOptions {
         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.
- */
+/** Returns whether this witness type has an authorization record. */
 export function isPluginAuthorized(options: IsPluginAuthorizedOptions) {
     const packageAddress = options.package ?? '@local-pkg/vault';
     const argumentsTypes = [

package/src/contracts.ts

@@ -9,12 +9,13 @@
 // re-exported from ITS `contracts` namespace — import it from there rather than
 // mirroring it here.
 
-// The record production line (pressing runs + their per-currency listings).
-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";
+// Record identity/issuance and Record Shop primary-sale mechanics. The
+// package-restricted witness constructor is intentionally not exported here.
+export * as record from "./contracts/miso_record/record.ts";
+export * as pressing from "./contracts/miso_record/pressing.ts";
+export * as listing from "./contracts/miso_record_shop/listing.ts";
 
-// Generic royalty-pool primitive plus vault-custodied business-logic plugins.
+// Generic royalty-pool primitive, raw-cap Actions, and the three safe crank 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";
@@ -23,6 +24,9 @@ export * as recordingRoyaltyPool from "./contracts/recording_royalty_pool/record
 export * as partyWallet from "./contracts/party_wallet/party_wallet.ts";
 export * as routedStake from "./contracts/routed_stake/routed_stake.ts";
 export * as compositionRoutedStake from "./contracts/composition_routed_stake/composition_routed_stake.ts";
+export * as compositionRoyaltyPoolPlugin from "./contracts/composition_royalty_pool_plugin/composition_royalty_pool_plugin.ts";
+export * as recordingRoyaltyPoolPlugin from "./contracts/recording_royalty_pool_plugin/recording_royalty_pool_plugin.ts";
+export * as releaseRevenueDistributorPlugin from "./contracts/release_revenue_distributor_plugin/release_revenue_distributor_plugin.ts";
 
 // Cover art (the CoverArt value type + the release attachment extension).
 export * as coverArt from "./contracts/cover_art/cover_art.ts";