@misofm/sdk 0.9.0 → 0.11.0

package/src/contracts/recording_royalty_pool/recording_royalty_pool.ts

@@ -4,29 +4,87 @@
 
 
 /**
- * Cap-gated royalty-pool extension for `Recording`.
+ * Vault-authorized royalty-pool business logic for Miso Recordings.
  * 
- * Royalty payers send `Coin<Currency>` directly to the recording's address — a
- * stable, well-known inbox available from the recording's creation. The recording
- * admin (cap holder) folds those funds into the underlying
- * `royalty_pool::pool::RoyaltyPool` via `receive_and_deposit` (for direct coin
- * transfers) or `redeem_and_deposit` (for funds-accumulator balances).
- * 
- * All three entry points require `&RecordingAdminCap`, so timing of fold
- * operations stays under admin control.
+ * The plugin temporarily leases the RecordingAdminCap from its Vault, uses it only
+ * to reach the matching Recording UID, and returns it before calling external pool
+ * logic. Pools remain derived from the Recording, not the Vault, so their
+ * canonical identity survives vault replacement.
  */
 
 import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
 import { normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+export interface InstallArguments {
+    vault: RawTransactionArgument<string>;
+    vaultAdminCap: RawTransactionArgument<string>;
+}
+export interface InstallOptions {
+    package?: string;
+    arguments: InstallArguments | [
+        vault: RawTransactionArgument<string>,
+        vaultAdminCap: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Authorize this package on a Recording capability Vault. */
+export function install(options: InstallOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_royalty_pool';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault", "vaultAdminCap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_royalty_pool',
+        function: 'install',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface UninstallArguments {
+    vault: RawTransactionArgument<string>;
+    vaultAdminCap: RawTransactionArgument<string>;
+}
+export interface UninstallOptions {
+    package?: string;
+    arguments: UninstallArguments | [
+        vault: RawTransactionArgument<string>,
+        vaultAdminCap: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Revoke this package from a Recording capability Vault. */
+export function uninstall(options: UninstallOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_royalty_pool';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault", "vaultAdminCap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_royalty_pool',
+        function: 'uninstall',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
 export interface InitializePoolArguments {
+    vault: RawTransactionArgument<string>;
     recording: RawTransactionArgument<string>;
-    cap: RawTransactionArgument<string>;
+    vaultAdminCap: RawTransactionArgument<string>;
 }
 export interface InitializePoolOptions {
     package?: string;
     arguments: InitializePoolArguments | [
+        vault: RawTransactionArgument<string>,
         recording: RawTransactionArgument<string>,
-        cap: RawTransactionArgument<string>
+        vaultAdminCap: RawTransactionArgument<string>
     ];
     typeArguments: [
         string,
@@ -35,17 +93,20 @@ export interface InitializePoolOptions {
     ];
 }
 /**
- * Create a royalty pool for a recording. Pool address derives from
- * `(recording_id, Currency)` — calling twice with the same Currency aborts because
- * the address is already claimed.
+ * Create and share the canonical pool derived from this Recording.
+ *
+ * The matching VaultAdminCap chooses which Currency pools may be created. The
+ * result cannot be redirected: the pool ID is claimed from the Recording UID and
+ * is typed by both RecordingShare and Currency.
  */
 export function initializePool(options: InitializePoolOptions) {
     const packageAddress = options.package ?? '@local-pkg/recording_royalty_pool';
     const argumentsTypes = [
+        null,
         null,
         null
     ] satisfies (string | null)[];
-    const parameterNames = ["recording", "cap"];
+    const parameterNames = ["vault", "recording", "vaultAdminCap"];
     return (tx: Transaction) => tx.moveCall({
         package: packageAddress,
         module: 'recording_royalty_pool',
@@ -55,18 +116,18 @@ export function initializePool(options: InitializePoolOptions) {
     });
 }
 export interface ReceiveAndDepositArguments {
+    vault: RawTransactionArgument<string>;
     recording: RawTransactionArgument<string>;
-    cap: RawTransactionArgument<string>;
-    coins: TransactionArgument;
     pool: RawTransactionArgument<string>;
+    coins: TransactionArgument;
 }
 export interface ReceiveAndDepositOptions {
     package?: string;
     arguments: ReceiveAndDepositArguments | [
+        vault: RawTransactionArgument<string>,
         recording: RawTransactionArgument<string>,
-        cap: RawTransactionArgument<string>,
-        coins: TransactionArgument,
-        pool: RawTransactionArgument<string>
+        pool: RawTransactionArgument<string>,
+        coins: TransactionArgument
     ];
     typeArguments: [
         string,
@@ -75,18 +136,19 @@ export interface ReceiveAndDepositOptions {
     ];
 }
 /**
- * Receive `Coin<Currency>` objects sent to the recording's address and fold them
- * into the pool's accumulator.
+ * Receive coins sent to the Recording and deposit them into its canonical pool.
+ * Anyone may crank this after the plugin is installed, but the funds can only
+ * reach the pool derived from this Recording.
  */
 export function receiveAndDeposit(options: ReceiveAndDepositOptions) {
     const packageAddress = options.package ?? '@local-pkg/recording_royalty_pool';
     const argumentsTypes = [
         null,
         null,
-        'vector<null>',
-        null
+        null,
+        'vector<null>'
     ] satisfies (string | null)[];
-    const parameterNames = ["recording", "cap", "coins", "pool"];
+    const parameterNames = ["vault", "recording", "pool", "coins"];
     return (tx: Transaction) => tx.moveCall({
         package: packageAddress,
         module: 'recording_royalty_pool',
@@ -96,18 +158,18 @@ export function receiveAndDeposit(options: ReceiveAndDepositOptions) {
     });
 }
 export interface RedeemAndDepositArguments {
+    vault: RawTransactionArgument<string>;
     recording: RawTransactionArgument<string>;
-    cap: RawTransactionArgument<string>;
-    value: RawTransactionArgument<number | bigint>;
     pool: RawTransactionArgument<string>;
+    value: RawTransactionArgument<number | bigint>;
 }
 export interface RedeemAndDepositOptions {
     package?: string;
     arguments: RedeemAndDepositArguments | [
+        vault: RawTransactionArgument<string>,
         recording: RawTransactionArgument<string>,
-        cap: RawTransactionArgument<string>,
-        value: RawTransactionArgument<number | bigint>,
-        pool: RawTransactionArgument<string>
+        pool: RawTransactionArgument<string>,
+        value: RawTransactionArgument<number | bigint>
     ];
     typeArguments: [
         string,
@@ -116,18 +178,18 @@ export interface RedeemAndDepositOptions {
     ];
 }
 /**
- * Redeem `value` base units from the recording's funds accumulator and fold the
- * resulting balance into the pool's accumulator.
+ * Redeem funds accumulated at the Recording address and deposit them into its
+ * canonical pool. Anyone may crank this after installation.
  */
 export function redeemAndDeposit(options: RedeemAndDepositOptions) {
     const packageAddress = options.package ?? '@local-pkg/recording_royalty_pool';
     const argumentsTypes = [
         null,
         null,
-        'u64',
-        null
+        null,
+        'u64'
     ] satisfies (string | null)[];
-    const parameterNames = ["recording", "cap", "value", "pool"];
+    const parameterNames = ["vault", "recording", "pool", "value"];
     return (tx: Transaction) => tx.moveCall({
         package: packageAddress,
         module: 'recording_royalty_pool',
@@ -135,4 +197,59 @@ export function redeemAndDeposit(options: RedeemAndDepositOptions) {
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
         typeArguments: options.typeArguments
     });
+}
+export interface IsInstalledArguments {
+    vault: RawTransactionArgument<string>;
+}
+export interface IsInstalledOptions {
+    package?: string;
+    arguments: IsInstalledArguments | [
+        vault: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export function isInstalled(options: IsInstalledOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_royalty_pool';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_royalty_pool',
+        function: 'is_installed',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface PoolAddressArguments {
+    recording: RawTransactionArgument<string>;
+}
+export interface PoolAddressOptions {
+    package?: string;
+    arguments: PoolAddressArguments | [
+        recording: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string,
+        string
+    ];
+}
+/** The canonical pool address for this Recording, share type, and Currency. */
+export function poolAddress(options: PoolAddressOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_royalty_pool';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["recording"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_royalty_pool',
+        function: 'pool_address',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
 }

package/src/contracts/recording_royalty_pool/witness.ts

@@ -0,0 +1,7 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveTuple } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = '@local-pkg/recording_royalty_pool::witness';
+export const Witness = new MoveTuple({ name: `${$moduleName}::Witness`, fields: [bcs.bool()] });

package/src/contracts/release_description/release_description.ts

@@ -0,0 +1,167 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * What a release says about itself — the paragraph that runs under the title,
+ * written by whoever holds the release's admin cap, and believed.
+ * 
+ * A free string, deliberately. Nothing on-chain reads it and nothing derives from
+ * it: this is editorial prose, not a fact the protocol can check. The facts a
+ * release carries that _are_ checkable — its tracklist, its splits, its state —
+ * live on the core object, and the claims two releases have to agree about to be
+ * comparable (genre, credits, languages) each get their own typed extension so
+ * they can be queried rather than read. What is left over is what a person wants
+ * to say, and the only useful thing to do with it is store it and attribute it to
+ * the cap holder.
+ * 
+ * One slot, not a set. A release has one thing to say about itself; per-track
+ * notes and per-language translations are different concerns and would be
+ * different extensions. Folding either in here would turn a paragraph into a
+ * schema, and a schema is exactly what prose is not.
+ * 
+ * The 8 KB ceiling is storage hygiene, not an editorial opinion — a backstop
+ * against pathological bloat in a shared object, deliberately set well above any
+ * description anyone is expected to write. It is the most generous free-text bound
+ * in the stack, and that is the intended asymmetry: this package publishes
+ * immutable, so a ceiling that turns out to be too low can never be raised, while
+ * one that is too high costs only the gas of the writer who fills it. A
+ * description is also edited rarely, so the cost of rewriting the field in full
+ * lands on almost nobody.
+ * 
+ * Genuinely long-form writing — an essay, a full set of liner notes — still
+ * belongs where the artwork goes, in a Walrus blob referenced by an extension.
+ * Nothing here stops someone using the whole 8 KB; the bound is a limit, not a
+ * recommendation.
+ * 
+ * Attaching nothing and attaching a description are distinct states: absence means
+ * nobody has written one, which is why an empty string is rejected rather than
+ * stored. There is no such thing as an empty description.
+ */
+
+import { MoveTuple, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction } from '@mysten/sui/transactions';
+const $moduleName = '@local-pkg/release_description::release_description';
+export const ExtensionKey = new MoveTuple({ name: `${$moduleName}::ExtensionKey`, fields: [bcs.bool()] });
+export const DescriptionSetEvent = new MoveStruct({ name: `${$moduleName}::DescriptionSetEvent`, fields: {
+        release_id: bcs.Address,
+        description: bcs.string()
+    } });
+export const DescriptionClearedEvent = new MoveStruct({ name: `${$moduleName}::DescriptionClearedEvent`, fields: {
+        release_id: bcs.Address
+    } });
+export interface SetDescriptionArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    description: RawTransactionArgument<string>;
+}
+export interface SetDescriptionOptions {
+    package?: string;
+    arguments: SetDescriptionArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        description: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Sets (or replaces) what the release says about itself.
+ *
+ * Stored exactly as given — whitespace, line breaks and case included. It is the
+ * release's own words, and normalising them here would be the protocol editing
+ * prose it has already declined to interpret.
+ */
+export function setDescription(options: SetDescriptionOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_description';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x1::string::String'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "description"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_description',
+        function: 'set_description',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface ClearDescriptionArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+}
+export interface ClearDescriptionOptions {
+    package?: string;
+    arguments: ClearDescriptionArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Removes the description, if any. Idempotent. Leaves the release having said
+ * nothing about itself, which is where every release starts.
+ */
+export function clearDescription(options: ClearDescriptionOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_description';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_description',
+        function: 'clear_description',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface HasDescriptionArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface HasDescriptionOptions {
+    package?: string;
+    arguments: HasDescriptionArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/** Whether a description is attached to this release. */
+export function hasDescription(options: HasDescriptionOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_description';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_description',
+        function: 'has_description',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface DescriptionArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface DescriptionOptions {
+    package?: string;
+    arguments: DescriptionArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/**
+ * What the release says about itself. Aborts if nothing is attached — absence is a
+ * distinct state and must not collapse into an empty string.
+ */
+export function description(options: DescriptionOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_description';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_description',
+        function: 'description',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}